/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
"use strict";

var $protobuf = require("protobufjs/minimal.js");

// Common aliases
var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;

// Exported root namespace
var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});

$root.protoCmd = (function() {

    /**
     * Namespace protoCmd.
     * @exports protoCmd
     * @namespace
     */
    var protoCmd = {};

    protoCmd.ProtocolParam = (function() {

        /**
         * Properties of a ProtocolParam.
         * @memberof protoCmd
         * @interface IProtocolParam
         * @property {string|null} [type] ProtocolParam type
         * @property {protoCmd.IRequest|null} [request] ProtocolParam request
         * @property {protoCmd.IResponse|null} [response] ProtocolParam response
         */

        /**
         * Constructs a new ProtocolParam.
         * @memberof protoCmd
         * @classdesc Represents a ProtocolParam.
         * @implements IProtocolParam
         * @constructor
         * @param {protoCmd.IProtocolParam=} [properties] Properties to set
         */
        function ProtocolParam(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * ProtocolParam type.
         * @member {string} type
         * @memberof protoCmd.ProtocolParam
         * @instance
         */
        ProtocolParam.prototype.type = "";

        /**
         * ProtocolParam request.
         * @member {protoCmd.IRequest|null|undefined} request
         * @memberof protoCmd.ProtocolParam
         * @instance
         */
        ProtocolParam.prototype.request = null;

        /**
         * ProtocolParam response.
         * @member {protoCmd.IResponse|null|undefined} response
         * @memberof protoCmd.ProtocolParam
         * @instance
         */
        ProtocolParam.prototype.response = null;

        /**
         * Creates a new ProtocolParam instance using the specified properties.
         * @function create
         * @memberof protoCmd.ProtocolParam
         * @static
         * @param {protoCmd.IProtocolParam=} [properties] Properties to set
         * @returns {protoCmd.ProtocolParam} ProtocolParam instance
         */
        ProtocolParam.create = function create(properties) {
            return new ProtocolParam(properties);
        };

        /**
         * Encodes the specified ProtocolParam message. Does not implicitly {@link protoCmd.ProtocolParam.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.ProtocolParam
         * @static
         * @param {protoCmd.IProtocolParam} message ProtocolParam message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        ProtocolParam.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                writer.uint32(/* id 1, wireType 2 =*/10).string(message.type);
            if (message.request != null && Object.hasOwnProperty.call(message, "request"))
                $root.protoCmd.Request.encode(message.request, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
            if (message.response != null && Object.hasOwnProperty.call(message, "response"))
                $root.protoCmd.Response.encode(message.response, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified ProtocolParam message, length delimited. Does not implicitly {@link protoCmd.ProtocolParam.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.ProtocolParam
         * @static
         * @param {protoCmd.IProtocolParam} message ProtocolParam message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        ProtocolParam.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a ProtocolParam message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.ProtocolParam
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.ProtocolParam} ProtocolParam
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        ProtocolParam.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.ProtocolParam();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.type = reader.string();
                    break;
                case 2:
                    message.request = $root.protoCmd.Request.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.response = $root.protoCmd.Response.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a ProtocolParam message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.ProtocolParam
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.ProtocolParam} ProtocolParam
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        ProtocolParam.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a ProtocolParam message.
         * @function verify
         * @memberof protoCmd.ProtocolParam
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        ProtocolParam.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.type != null && message.hasOwnProperty("type"))
                if (!$util.isString(message.type))
                    return "type: string expected";
            if (message.request != null && message.hasOwnProperty("request")) {
                var error = $root.protoCmd.Request.verify(message.request);
                if (error)
                    return "request." + error;
            }
            if (message.response != null && message.hasOwnProperty("response")) {
                var error = $root.protoCmd.Response.verify(message.response);
                if (error)
                    return "response." + error;
            }
            return null;
        };

        /**
         * Creates a ProtocolParam message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.ProtocolParam
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.ProtocolParam} ProtocolParam
         */
        ProtocolParam.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.ProtocolParam)
                return object;
            var message = new $root.protoCmd.ProtocolParam();
            if (object.type != null)
                message.type = String(object.type);
            if (object.request != null) {
                if (typeof object.request !== "object")
                    throw TypeError(".protoCmd.ProtocolParam.request: object expected");
                message.request = $root.protoCmd.Request.fromObject(object.request);
            }
            if (object.response != null) {
                if (typeof object.response !== "object")
                    throw TypeError(".protoCmd.ProtocolParam.response: object expected");
                message.response = $root.protoCmd.Response.fromObject(object.response);
            }
            return message;
        };

        /**
         * Creates a plain object from a ProtocolParam message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.ProtocolParam
         * @static
         * @param {protoCmd.ProtocolParam} message ProtocolParam
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        ProtocolParam.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                object.type = "";
                object.request = null;
                object.response = null;
            }
            if (message.type != null && message.hasOwnProperty("type"))
                object.type = message.type;
            if (message.request != null && message.hasOwnProperty("request"))
                object.request = $root.protoCmd.Request.toObject(message.request, options);
            if (message.response != null && message.hasOwnProperty("response"))
                object.response = $root.protoCmd.Response.toObject(message.response, options);
            return object;
        };

        /**
         * Converts this ProtocolParam to JSON.
         * @function toJSON
         * @memberof protoCmd.ProtocolParam
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        ProtocolParam.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return ProtocolParam;
    })();

    protoCmd.Request = (function() {

        /**
         * Properties of a Request.
         * @memberof protoCmd
         * @interface IRequest
         * @property {protoCmd.IloginReq|null} [loginReq] Request loginReq
         * @property {protoCmd.IgetAllPetReq|null} [getAllPetReq] Request getAllPetReq
         * @property {protoCmd.IgetPetReq|null} [getPetReq] Request getPetReq
         * @property {protoCmd.IcommodityReq|null} [commodityReq] Request commodityReq
         * @property {protoCmd.IchangeHeadReq|null} [changeHeadReq] Request changeHeadReq
         * @property {protoCmd.IabandonPetReq|null} [abandonPetReq] Request abandonPetReq
         * @property {protoCmd.IallPetCareReq|null} [allPetCareReq] Request allPetCareReq
         * @property {protoCmd.IpetOperateReq|null} [petOperateReq] Request petOperateReq
         * @property {protoCmd.IchangeUserNameReq|null} [changeUserNameReq] Request changeUserNameReq
         * @property {protoCmd.IpetNameChangeReq|null} [petNameChangeReq] Request petNameChangeReq
         * @property {protoCmd.IpetExpReq|null} [petExpReq] Request petExpReq
         * @property {protoCmd.ImaintenanceReq|null} [maintenanceReq] Request maintenanceReq
         * @property {protoCmd.IwanderPetAbandonReq|null} [wanderPetAbandonReq] Request wanderPetAbandonReq
         * @property {protoCmd.IwanderPetAdoptReq|null} [wanderPetAdoptReq] Request wanderPetAdoptReq
         * @property {protoCmd.IaddPetWaterReq|null} [addPetWaterReq] Request addPetWaterReq
         * @property {protoCmd.IaddPetFoodReq|null} [addPetFoodReq] Request addPetFoodReq
         * @property {protoCmd.IaddPetWaterMaxReq|null} [addPetWaterMaxReq] Request addPetWaterMaxReq
         * @property {protoCmd.IaddPetFoodMaxReq|null} [addPetFoodMaxReq] Request addPetFoodMaxReq
         * @property {protoCmd.IglobalHeartPing|null} [globalHeartPing] Request globalHeartPing
         * @property {protoCmd.Itaskreq|null} [taskreq] Request taskreq
         * @property {protoCmd.ItaskBoxreq|null} [taskBoxreq] Request taskBoxreq
         * @property {protoCmd.IgetReardHitReq|null} [getReardHitReq] Request getReardHitReq
         * @property {protoCmd.IsendGmReq|null} [sendGmReq] Request sendGmReq
         * @property {protoCmd.IsidebarRewardReq|null} [sidebarRewardReq] Request sidebarRewardReq
         * @property {protoCmd.IcdkUseReq|null} [cdkUseReq] Request cdkUseReq
         * @property {protoCmd.IgetCutPowerReq|null} [getCutPowerReq] Request getCutPowerReq
         * @property {protoCmd.ImailSingleReq|null} [mailSingleReq] Request mailSingleReq
         * @property {protoCmd.ImailRewardReq|null} [mailRewardReq] Request mailRewardReq
         * @property {protoCmd.ImailAllReq|null} [mailAllReq] Request mailAllReq
         * @property {protoCmd.ImailDelAllReq|null} [mailDelAllReq] Request mailDelAllReq
         * @property {protoCmd.IfriendReq|null} [friendReq] Request friendReq
         * @property {protoCmd.IfriendAddReq|null} [friendAddReq] Request friendAddReq
         * @property {protoCmd.IfriendDelReq|null} [friendDelReq] Request friendDelReq
         * @property {protoCmd.ItempFriendReq|null} [tempFriendReq] Request tempFriendReq
         * @property {protoCmd.IaddTempFriendReq|null} [addTempFriendReq] Request addTempFriendReq
         * @property {protoCmd.IsearchFriendReq|null} [searchFriendReq] Request searchFriendReq
         */

        /**
         * Constructs a new Request.
         * @memberof protoCmd
         * @classdesc Represents a Request.
         * @implements IRequest
         * @constructor
         * @param {protoCmd.IRequest=} [properties] Properties to set
         */
        function Request(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Request loginReq.
         * @member {protoCmd.IloginReq|null|undefined} loginReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.loginReq = null;

        /**
         * Request getAllPetReq.
         * @member {protoCmd.IgetAllPetReq|null|undefined} getAllPetReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.getAllPetReq = null;

        /**
         * Request getPetReq.
         * @member {protoCmd.IgetPetReq|null|undefined} getPetReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.getPetReq = null;

        /**
         * Request commodityReq.
         * @member {protoCmd.IcommodityReq|null|undefined} commodityReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.commodityReq = null;

        /**
         * Request changeHeadReq.
         * @member {protoCmd.IchangeHeadReq|null|undefined} changeHeadReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.changeHeadReq = null;

        /**
         * Request abandonPetReq.
         * @member {protoCmd.IabandonPetReq|null|undefined} abandonPetReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.abandonPetReq = null;

        /**
         * Request allPetCareReq.
         * @member {protoCmd.IallPetCareReq|null|undefined} allPetCareReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.allPetCareReq = null;

        /**
         * Request petOperateReq.
         * @member {protoCmd.IpetOperateReq|null|undefined} petOperateReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.petOperateReq = null;

        /**
         * Request changeUserNameReq.
         * @member {protoCmd.IchangeUserNameReq|null|undefined} changeUserNameReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.changeUserNameReq = null;

        /**
         * Request petNameChangeReq.
         * @member {protoCmd.IpetNameChangeReq|null|undefined} petNameChangeReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.petNameChangeReq = null;

        /**
         * Request petExpReq.
         * @member {protoCmd.IpetExpReq|null|undefined} petExpReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.petExpReq = null;

        /**
         * Request maintenanceReq.
         * @member {protoCmd.ImaintenanceReq|null|undefined} maintenanceReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.maintenanceReq = null;

        /**
         * Request wanderPetAbandonReq.
         * @member {protoCmd.IwanderPetAbandonReq|null|undefined} wanderPetAbandonReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.wanderPetAbandonReq = null;

        /**
         * Request wanderPetAdoptReq.
         * @member {protoCmd.IwanderPetAdoptReq|null|undefined} wanderPetAdoptReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.wanderPetAdoptReq = null;

        /**
         * Request addPetWaterReq.
         * @member {protoCmd.IaddPetWaterReq|null|undefined} addPetWaterReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.addPetWaterReq = null;

        /**
         * Request addPetFoodReq.
         * @member {protoCmd.IaddPetFoodReq|null|undefined} addPetFoodReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.addPetFoodReq = null;

        /**
         * Request addPetWaterMaxReq.
         * @member {protoCmd.IaddPetWaterMaxReq|null|undefined} addPetWaterMaxReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.addPetWaterMaxReq = null;

        /**
         * Request addPetFoodMaxReq.
         * @member {protoCmd.IaddPetFoodMaxReq|null|undefined} addPetFoodMaxReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.addPetFoodMaxReq = null;

        /**
         * Request globalHeartPing.
         * @member {protoCmd.IglobalHeartPing|null|undefined} globalHeartPing
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.globalHeartPing = null;

        /**
         * Request taskreq.
         * @member {protoCmd.Itaskreq|null|undefined} taskreq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.taskreq = null;

        /**
         * Request taskBoxreq.
         * @member {protoCmd.ItaskBoxreq|null|undefined} taskBoxreq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.taskBoxreq = null;

        /**
         * Request getReardHitReq.
         * @member {protoCmd.IgetReardHitReq|null|undefined} getReardHitReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.getReardHitReq = null;

        /**
         * Request sendGmReq.
         * @member {protoCmd.IsendGmReq|null|undefined} sendGmReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.sendGmReq = null;

        /**
         * Request sidebarRewardReq.
         * @member {protoCmd.IsidebarRewardReq|null|undefined} sidebarRewardReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.sidebarRewardReq = null;

        /**
         * Request cdkUseReq.
         * @member {protoCmd.IcdkUseReq|null|undefined} cdkUseReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.cdkUseReq = null;

        /**
         * Request getCutPowerReq.
         * @member {protoCmd.IgetCutPowerReq|null|undefined} getCutPowerReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.getCutPowerReq = null;

        /**
         * Request mailSingleReq.
         * @member {protoCmd.ImailSingleReq|null|undefined} mailSingleReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.mailSingleReq = null;

        /**
         * Request mailRewardReq.
         * @member {protoCmd.ImailRewardReq|null|undefined} mailRewardReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.mailRewardReq = null;

        /**
         * Request mailAllReq.
         * @member {protoCmd.ImailAllReq|null|undefined} mailAllReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.mailAllReq = null;

        /**
         * Request mailDelAllReq.
         * @member {protoCmd.ImailDelAllReq|null|undefined} mailDelAllReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.mailDelAllReq = null;

        /**
         * Request friendReq.
         * @member {protoCmd.IfriendReq|null|undefined} friendReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.friendReq = null;

        /**
         * Request friendAddReq.
         * @member {protoCmd.IfriendAddReq|null|undefined} friendAddReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.friendAddReq = null;

        /**
         * Request friendDelReq.
         * @member {protoCmd.IfriendDelReq|null|undefined} friendDelReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.friendDelReq = null;

        /**
         * Request tempFriendReq.
         * @member {protoCmd.ItempFriendReq|null|undefined} tempFriendReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.tempFriendReq = null;

        /**
         * Request addTempFriendReq.
         * @member {protoCmd.IaddTempFriendReq|null|undefined} addTempFriendReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.addTempFriendReq = null;

        /**
         * Request searchFriendReq.
         * @member {protoCmd.IsearchFriendReq|null|undefined} searchFriendReq
         * @memberof protoCmd.Request
         * @instance
         */
        Request.prototype.searchFriendReq = null;

        /**
         * Creates a new Request instance using the specified properties.
         * @function create
         * @memberof protoCmd.Request
         * @static
         * @param {protoCmd.IRequest=} [properties] Properties to set
         * @returns {protoCmd.Request} Request instance
         */
        Request.create = function create(properties) {
            return new Request(properties);
        };

        /**
         * Encodes the specified Request message. Does not implicitly {@link protoCmd.Request.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.Request
         * @static
         * @param {protoCmd.IRequest} message Request message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        Request.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.loginReq != null && Object.hasOwnProperty.call(message, "loginReq"))
                $root.protoCmd.loginReq.encode(message.loginReq, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
            if (message.getAllPetReq != null && Object.hasOwnProperty.call(message, "getAllPetReq"))
                $root.protoCmd.getAllPetReq.encode(message.getAllPetReq, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
            if (message.getPetReq != null && Object.hasOwnProperty.call(message, "getPetReq"))
                $root.protoCmd.getPetReq.encode(message.getPetReq, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
            if (message.commodityReq != null && Object.hasOwnProperty.call(message, "commodityReq"))
                $root.protoCmd.commodityReq.encode(message.commodityReq, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
            if (message.changeHeadReq != null && Object.hasOwnProperty.call(message, "changeHeadReq"))
                $root.protoCmd.changeHeadReq.encode(message.changeHeadReq, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
            if (message.abandonPetReq != null && Object.hasOwnProperty.call(message, "abandonPetReq"))
                $root.protoCmd.abandonPetReq.encode(message.abandonPetReq, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim();
            if (message.allPetCareReq != null && Object.hasOwnProperty.call(message, "allPetCareReq"))
                $root.protoCmd.allPetCareReq.encode(message.allPetCareReq, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
            if (message.petOperateReq != null && Object.hasOwnProperty.call(message, "petOperateReq"))
                $root.protoCmd.petOperateReq.encode(message.petOperateReq, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();
            if (message.changeUserNameReq != null && Object.hasOwnProperty.call(message, "changeUserNameReq"))
                $root.protoCmd.changeUserNameReq.encode(message.changeUserNameReq, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();
            if (message.petNameChangeReq != null && Object.hasOwnProperty.call(message, "petNameChangeReq"))
                $root.protoCmd.petNameChangeReq.encode(message.petNameChangeReq, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim();
            if (message.petExpReq != null && Object.hasOwnProperty.call(message, "petExpReq"))
                $root.protoCmd.petExpReq.encode(message.petExpReq, writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim();
            if (message.maintenanceReq != null && Object.hasOwnProperty.call(message, "maintenanceReq"))
                $root.protoCmd.maintenanceReq.encode(message.maintenanceReq, writer.uint32(/* id 12, wireType 2 =*/98).fork()).ldelim();
            if (message.wanderPetAbandonReq != null && Object.hasOwnProperty.call(message, "wanderPetAbandonReq"))
                $root.protoCmd.wanderPetAbandonReq.encode(message.wanderPetAbandonReq, writer.uint32(/* id 13, wireType 2 =*/106).fork()).ldelim();
            if (message.wanderPetAdoptReq != null && Object.hasOwnProperty.call(message, "wanderPetAdoptReq"))
                $root.protoCmd.wanderPetAdoptReq.encode(message.wanderPetAdoptReq, writer.uint32(/* id 14, wireType 2 =*/114).fork()).ldelim();
            if (message.addPetWaterReq != null && Object.hasOwnProperty.call(message, "addPetWaterReq"))
                $root.protoCmd.addPetWaterReq.encode(message.addPetWaterReq, writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim();
            if (message.addPetFoodReq != null && Object.hasOwnProperty.call(message, "addPetFoodReq"))
                $root.protoCmd.addPetFoodReq.encode(message.addPetFoodReq, writer.uint32(/* id 16, wireType 2 =*/130).fork()).ldelim();
            if (message.addPetWaterMaxReq != null && Object.hasOwnProperty.call(message, "addPetWaterMaxReq"))
                $root.protoCmd.addPetWaterMaxReq.encode(message.addPetWaterMaxReq, writer.uint32(/* id 17, wireType 2 =*/138).fork()).ldelim();
            if (message.addPetFoodMaxReq != null && Object.hasOwnProperty.call(message, "addPetFoodMaxReq"))
                $root.protoCmd.addPetFoodMaxReq.encode(message.addPetFoodMaxReq, writer.uint32(/* id 18, wireType 2 =*/146).fork()).ldelim();
            if (message.globalHeartPing != null && Object.hasOwnProperty.call(message, "globalHeartPing"))
                $root.protoCmd.globalHeartPing.encode(message.globalHeartPing, writer.uint32(/* id 19, wireType 2 =*/154).fork()).ldelim();
            if (message.taskreq != null && Object.hasOwnProperty.call(message, "taskreq"))
                $root.protoCmd.taskreq.encode(message.taskreq, writer.uint32(/* id 20, wireType 2 =*/162).fork()).ldelim();
            if (message.taskBoxreq != null && Object.hasOwnProperty.call(message, "taskBoxreq"))
                $root.protoCmd.taskBoxreq.encode(message.taskBoxreq, writer.uint32(/* id 21, wireType 2 =*/170).fork()).ldelim();
            if (message.getReardHitReq != null && Object.hasOwnProperty.call(message, "getReardHitReq"))
                $root.protoCmd.getReardHitReq.encode(message.getReardHitReq, writer.uint32(/* id 22, wireType 2 =*/178).fork()).ldelim();
            if (message.sendGmReq != null && Object.hasOwnProperty.call(message, "sendGmReq"))
                $root.protoCmd.sendGmReq.encode(message.sendGmReq, writer.uint32(/* id 23, wireType 2 =*/186).fork()).ldelim();
            if (message.sidebarRewardReq != null && Object.hasOwnProperty.call(message, "sidebarRewardReq"))
                $root.protoCmd.sidebarRewardReq.encode(message.sidebarRewardReq, writer.uint32(/* id 24, wireType 2 =*/194).fork()).ldelim();
            if (message.cdkUseReq != null && Object.hasOwnProperty.call(message, "cdkUseReq"))
                $root.protoCmd.cdkUseReq.encode(message.cdkUseReq, writer.uint32(/* id 25, wireType 2 =*/202).fork()).ldelim();
            if (message.getCutPowerReq != null && Object.hasOwnProperty.call(message, "getCutPowerReq"))
                $root.protoCmd.getCutPowerReq.encode(message.getCutPowerReq, writer.uint32(/* id 26, wireType 2 =*/210).fork()).ldelim();
            if (message.mailSingleReq != null && Object.hasOwnProperty.call(message, "mailSingleReq"))
                $root.protoCmd.mailSingleReq.encode(message.mailSingleReq, writer.uint32(/* id 27, wireType 2 =*/218).fork()).ldelim();
            if (message.mailRewardReq != null && Object.hasOwnProperty.call(message, "mailRewardReq"))
                $root.protoCmd.mailRewardReq.encode(message.mailRewardReq, writer.uint32(/* id 28, wireType 2 =*/226).fork()).ldelim();
            if (message.mailAllReq != null && Object.hasOwnProperty.call(message, "mailAllReq"))
                $root.protoCmd.mailAllReq.encode(message.mailAllReq, writer.uint32(/* id 29, wireType 2 =*/234).fork()).ldelim();
            if (message.mailDelAllReq != null && Object.hasOwnProperty.call(message, "mailDelAllReq"))
                $root.protoCmd.mailDelAllReq.encode(message.mailDelAllReq, writer.uint32(/* id 30, wireType 2 =*/242).fork()).ldelim();
            if (message.friendReq != null && Object.hasOwnProperty.call(message, "friendReq"))
                $root.protoCmd.friendReq.encode(message.friendReq, writer.uint32(/* id 31, wireType 2 =*/250).fork()).ldelim();
            if (message.friendAddReq != null && Object.hasOwnProperty.call(message, "friendAddReq"))
                $root.protoCmd.friendAddReq.encode(message.friendAddReq, writer.uint32(/* id 32, wireType 2 =*/258).fork()).ldelim();
            if (message.friendDelReq != null && Object.hasOwnProperty.call(message, "friendDelReq"))
                $root.protoCmd.friendDelReq.encode(message.friendDelReq, writer.uint32(/* id 33, wireType 2 =*/266).fork()).ldelim();
            if (message.tempFriendReq != null && Object.hasOwnProperty.call(message, "tempFriendReq"))
                $root.protoCmd.tempFriendReq.encode(message.tempFriendReq, writer.uint32(/* id 34, wireType 2 =*/274).fork()).ldelim();
            if (message.addTempFriendReq != null && Object.hasOwnProperty.call(message, "addTempFriendReq"))
                $root.protoCmd.addTempFriendReq.encode(message.addTempFriendReq, writer.uint32(/* id 35, wireType 2 =*/282).fork()).ldelim();
            if (message.searchFriendReq != null && Object.hasOwnProperty.call(message, "searchFriendReq"))
                $root.protoCmd.searchFriendReq.encode(message.searchFriendReq, writer.uint32(/* id 36, wireType 2 =*/290).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified Request message, length delimited. Does not implicitly {@link protoCmd.Request.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.Request
         * @static
         * @param {protoCmd.IRequest} message Request message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        Request.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a Request message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.Request
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.Request} Request
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        Request.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.Request();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.loginReq = $root.protoCmd.loginReq.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.getAllPetReq = $root.protoCmd.getAllPetReq.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.getPetReq = $root.protoCmd.getPetReq.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.commodityReq = $root.protoCmd.commodityReq.decode(reader, reader.uint32());
                    break;
                case 5:
                    message.changeHeadReq = $root.protoCmd.changeHeadReq.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.abandonPetReq = $root.protoCmd.abandonPetReq.decode(reader, reader.uint32());
                    break;
                case 7:
                    message.allPetCareReq = $root.protoCmd.allPetCareReq.decode(reader, reader.uint32());
                    break;
                case 8:
                    message.petOperateReq = $root.protoCmd.petOperateReq.decode(reader, reader.uint32());
                    break;
                case 9:
                    message.changeUserNameReq = $root.protoCmd.changeUserNameReq.decode(reader, reader.uint32());
                    break;
                case 10:
                    message.petNameChangeReq = $root.protoCmd.petNameChangeReq.decode(reader, reader.uint32());
                    break;
                case 11:
                    message.petExpReq = $root.protoCmd.petExpReq.decode(reader, reader.uint32());
                    break;
                case 12:
                    message.maintenanceReq = $root.protoCmd.maintenanceReq.decode(reader, reader.uint32());
                    break;
                case 13:
                    message.wanderPetAbandonReq = $root.protoCmd.wanderPetAbandonReq.decode(reader, reader.uint32());
                    break;
                case 14:
                    message.wanderPetAdoptReq = $root.protoCmd.wanderPetAdoptReq.decode(reader, reader.uint32());
                    break;
                case 15:
                    message.addPetWaterReq = $root.protoCmd.addPetWaterReq.decode(reader, reader.uint32());
                    break;
                case 16:
                    message.addPetFoodReq = $root.protoCmd.addPetFoodReq.decode(reader, reader.uint32());
                    break;
                case 17:
                    message.addPetWaterMaxReq = $root.protoCmd.addPetWaterMaxReq.decode(reader, reader.uint32());
                    break;
                case 18:
                    message.addPetFoodMaxReq = $root.protoCmd.addPetFoodMaxReq.decode(reader, reader.uint32());
                    break;
                case 19:
                    message.globalHeartPing = $root.protoCmd.globalHeartPing.decode(reader, reader.uint32());
                    break;
                case 20:
                    message.taskreq = $root.protoCmd.taskreq.decode(reader, reader.uint32());
                    break;
                case 21:
                    message.taskBoxreq = $root.protoCmd.taskBoxreq.decode(reader, reader.uint32());
                    break;
                case 22:
                    message.getReardHitReq = $root.protoCmd.getReardHitReq.decode(reader, reader.uint32());
                    break;
                case 23:
                    message.sendGmReq = $root.protoCmd.sendGmReq.decode(reader, reader.uint32());
                    break;
                case 24:
                    message.sidebarRewardReq = $root.protoCmd.sidebarRewardReq.decode(reader, reader.uint32());
                    break;
                case 25:
                    message.cdkUseReq = $root.protoCmd.cdkUseReq.decode(reader, reader.uint32());
                    break;
                case 26:
                    message.getCutPowerReq = $root.protoCmd.getCutPowerReq.decode(reader, reader.uint32());
                    break;
                case 27:
                    message.mailSingleReq = $root.protoCmd.mailSingleReq.decode(reader, reader.uint32());
                    break;
                case 28:
                    message.mailRewardReq = $root.protoCmd.mailRewardReq.decode(reader, reader.uint32());
                    break;
                case 29:
                    message.mailAllReq = $root.protoCmd.mailAllReq.decode(reader, reader.uint32());
                    break;
                case 30:
                    message.mailDelAllReq = $root.protoCmd.mailDelAllReq.decode(reader, reader.uint32());
                    break;
                case 31:
                    message.friendReq = $root.protoCmd.friendReq.decode(reader, reader.uint32());
                    break;
                case 32:
                    message.friendAddReq = $root.protoCmd.friendAddReq.decode(reader, reader.uint32());
                    break;
                case 33:
                    message.friendDelReq = $root.protoCmd.friendDelReq.decode(reader, reader.uint32());
                    break;
                case 34:
                    message.tempFriendReq = $root.protoCmd.tempFriendReq.decode(reader, reader.uint32());
                    break;
                case 35:
                    message.addTempFriendReq = $root.protoCmd.addTempFriendReq.decode(reader, reader.uint32());
                    break;
                case 36:
                    message.searchFriendReq = $root.protoCmd.searchFriendReq.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a Request message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.Request
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.Request} Request
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        Request.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a Request message.
         * @function verify
         * @memberof protoCmd.Request
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        Request.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.loginReq != null && message.hasOwnProperty("loginReq")) {
                var error = $root.protoCmd.loginReq.verify(message.loginReq);
                if (error)
                    return "loginReq." + error;
            }
            if (message.getAllPetReq != null && message.hasOwnProperty("getAllPetReq")) {
                var error = $root.protoCmd.getAllPetReq.verify(message.getAllPetReq);
                if (error)
                    return "getAllPetReq." + error;
            }
            if (message.getPetReq != null && message.hasOwnProperty("getPetReq")) {
                var error = $root.protoCmd.getPetReq.verify(message.getPetReq);
                if (error)
                    return "getPetReq." + error;
            }
            if (message.commodityReq != null && message.hasOwnProperty("commodityReq")) {
                var error = $root.protoCmd.commodityReq.verify(message.commodityReq);
                if (error)
                    return "commodityReq." + error;
            }
            if (message.changeHeadReq != null && message.hasOwnProperty("changeHeadReq")) {
                var error = $root.protoCmd.changeHeadReq.verify(message.changeHeadReq);
                if (error)
                    return "changeHeadReq." + error;
            }
            if (message.abandonPetReq != null && message.hasOwnProperty("abandonPetReq")) {
                var error = $root.protoCmd.abandonPetReq.verify(message.abandonPetReq);
                if (error)
                    return "abandonPetReq." + error;
            }
            if (message.allPetCareReq != null && message.hasOwnProperty("allPetCareReq")) {
                var error = $root.protoCmd.allPetCareReq.verify(message.allPetCareReq);
                if (error)
                    return "allPetCareReq." + error;
            }
            if (message.petOperateReq != null && message.hasOwnProperty("petOperateReq")) {
                var error = $root.protoCmd.petOperateReq.verify(message.petOperateReq);
                if (error)
                    return "petOperateReq." + error;
            }
            if (message.changeUserNameReq != null && message.hasOwnProperty("changeUserNameReq")) {
                var error = $root.protoCmd.changeUserNameReq.verify(message.changeUserNameReq);
                if (error)
                    return "changeUserNameReq." + error;
            }
            if (message.petNameChangeReq != null && message.hasOwnProperty("petNameChangeReq")) {
                var error = $root.protoCmd.petNameChangeReq.verify(message.petNameChangeReq);
                if (error)
                    return "petNameChangeReq." + error;
            }
            if (message.petExpReq != null && message.hasOwnProperty("petExpReq")) {
                var error = $root.protoCmd.petExpReq.verify(message.petExpReq);
                if (error)
                    return "petExpReq." + error;
            }
            if (message.maintenanceReq != null && message.hasOwnProperty("maintenanceReq")) {
                var error = $root.protoCmd.maintenanceReq.verify(message.maintenanceReq);
                if (error)
                    return "maintenanceReq." + error;
            }
            if (message.wanderPetAbandonReq != null && message.hasOwnProperty("wanderPetAbandonReq")) {
                var error = $root.protoCmd.wanderPetAbandonReq.verify(message.wanderPetAbandonReq);
                if (error)
                    return "wanderPetAbandonReq." + error;
            }
            if (message.wanderPetAdoptReq != null && message.hasOwnProperty("wanderPetAdoptReq")) {
                var error = $root.protoCmd.wanderPetAdoptReq.verify(message.wanderPetAdoptReq);
                if (error)
                    return "wanderPetAdoptReq." + error;
            }
            if (message.addPetWaterReq != null && message.hasOwnProperty("addPetWaterReq")) {
                var error = $root.protoCmd.addPetWaterReq.verify(message.addPetWaterReq);
                if (error)
                    return "addPetWaterReq." + error;
            }
            if (message.addPetFoodReq != null && message.hasOwnProperty("addPetFoodReq")) {
                var error = $root.protoCmd.addPetFoodReq.verify(message.addPetFoodReq);
                if (error)
                    return "addPetFoodReq." + error;
            }
            if (message.addPetWaterMaxReq != null && message.hasOwnProperty("addPetWaterMaxReq")) {
                var error = $root.protoCmd.addPetWaterMaxReq.verify(message.addPetWaterMaxReq);
                if (error)
                    return "addPetWaterMaxReq." + error;
            }
            if (message.addPetFoodMaxReq != null && message.hasOwnProperty("addPetFoodMaxReq")) {
                var error = $root.protoCmd.addPetFoodMaxReq.verify(message.addPetFoodMaxReq);
                if (error)
                    return "addPetFoodMaxReq." + error;
            }
            if (message.globalHeartPing != null && message.hasOwnProperty("globalHeartPing")) {
                var error = $root.protoCmd.globalHeartPing.verify(message.globalHeartPing);
                if (error)
                    return "globalHeartPing." + error;
            }
            if (message.taskreq != null && message.hasOwnProperty("taskreq")) {
                var error = $root.protoCmd.taskreq.verify(message.taskreq);
                if (error)
                    return "taskreq." + error;
            }
            if (message.taskBoxreq != null && message.hasOwnProperty("taskBoxreq")) {
                var error = $root.protoCmd.taskBoxreq.verify(message.taskBoxreq);
                if (error)
                    return "taskBoxreq." + error;
            }
            if (message.getReardHitReq != null && message.hasOwnProperty("getReardHitReq")) {
                var error = $root.protoCmd.getReardHitReq.verify(message.getReardHitReq);
                if (error)
                    return "getReardHitReq." + error;
            }
            if (message.sendGmReq != null && message.hasOwnProperty("sendGmReq")) {
                var error = $root.protoCmd.sendGmReq.verify(message.sendGmReq);
                if (error)
                    return "sendGmReq." + error;
            }
            if (message.sidebarRewardReq != null && message.hasOwnProperty("sidebarRewardReq")) {
                var error = $root.protoCmd.sidebarRewardReq.verify(message.sidebarRewardReq);
                if (error)
                    return "sidebarRewardReq." + error;
            }
            if (message.cdkUseReq != null && message.hasOwnProperty("cdkUseReq")) {
                var error = $root.protoCmd.cdkUseReq.verify(message.cdkUseReq);
                if (error)
                    return "cdkUseReq." + error;
            }
            if (message.getCutPowerReq != null && message.hasOwnProperty("getCutPowerReq")) {
                var error = $root.protoCmd.getCutPowerReq.verify(message.getCutPowerReq);
                if (error)
                    return "getCutPowerReq." + error;
            }
            if (message.mailSingleReq != null && message.hasOwnProperty("mailSingleReq")) {
                var error = $root.protoCmd.mailSingleReq.verify(message.mailSingleReq);
                if (error)
                    return "mailSingleReq." + error;
            }
            if (message.mailRewardReq != null && message.hasOwnProperty("mailRewardReq")) {
                var error = $root.protoCmd.mailRewardReq.verify(message.mailRewardReq);
                if (error)
                    return "mailRewardReq." + error;
            }
            if (message.mailAllReq != null && message.hasOwnProperty("mailAllReq")) {
                var error = $root.protoCmd.mailAllReq.verify(message.mailAllReq);
                if (error)
                    return "mailAllReq." + error;
            }
            if (message.mailDelAllReq != null && message.hasOwnProperty("mailDelAllReq")) {
                var error = $root.protoCmd.mailDelAllReq.verify(message.mailDelAllReq);
                if (error)
                    return "mailDelAllReq." + error;
            }
            if (message.friendReq != null && message.hasOwnProperty("friendReq")) {
                var error = $root.protoCmd.friendReq.verify(message.friendReq);
                if (error)
                    return "friendReq." + error;
            }
            if (message.friendAddReq != null && message.hasOwnProperty("friendAddReq")) {
                var error = $root.protoCmd.friendAddReq.verify(message.friendAddReq);
                if (error)
                    return "friendAddReq." + error;
            }
            if (message.friendDelReq != null && message.hasOwnProperty("friendDelReq")) {
                var error = $root.protoCmd.friendDelReq.verify(message.friendDelReq);
                if (error)
                    return "friendDelReq." + error;
            }
            if (message.tempFriendReq != null && message.hasOwnProperty("tempFriendReq")) {
                var error = $root.protoCmd.tempFriendReq.verify(message.tempFriendReq);
                if (error)
                    return "tempFriendReq." + error;
            }
            if (message.addTempFriendReq != null && message.hasOwnProperty("addTempFriendReq")) {
                var error = $root.protoCmd.addTempFriendReq.verify(message.addTempFriendReq);
                if (error)
                    return "addTempFriendReq." + error;
            }
            if (message.searchFriendReq != null && message.hasOwnProperty("searchFriendReq")) {
                var error = $root.protoCmd.searchFriendReq.verify(message.searchFriendReq);
                if (error)
                    return "searchFriendReq." + error;
            }
            return null;
        };

        /**
         * Creates a Request message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.Request
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.Request} Request
         */
        Request.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.Request)
                return object;
            var message = new $root.protoCmd.Request();
            if (object.loginReq != null) {
                if (typeof object.loginReq !== "object")
                    throw TypeError(".protoCmd.Request.loginReq: object expected");
                message.loginReq = $root.protoCmd.loginReq.fromObject(object.loginReq);
            }
            if (object.getAllPetReq != null) {
                if (typeof object.getAllPetReq !== "object")
                    throw TypeError(".protoCmd.Request.getAllPetReq: object expected");
                message.getAllPetReq = $root.protoCmd.getAllPetReq.fromObject(object.getAllPetReq);
            }
            if (object.getPetReq != null) {
                if (typeof object.getPetReq !== "object")
                    throw TypeError(".protoCmd.Request.getPetReq: object expected");
                message.getPetReq = $root.protoCmd.getPetReq.fromObject(object.getPetReq);
            }
            if (object.commodityReq != null) {
                if (typeof object.commodityReq !== "object")
                    throw TypeError(".protoCmd.Request.commodityReq: object expected");
                message.commodityReq = $root.protoCmd.commodityReq.fromObject(object.commodityReq);
            }
            if (object.changeHeadReq != null) {
                if (typeof object.changeHeadReq !== "object")
                    throw TypeError(".protoCmd.Request.changeHeadReq: object expected");
                message.changeHeadReq = $root.protoCmd.changeHeadReq.fromObject(object.changeHeadReq);
            }
            if (object.abandonPetReq != null) {
                if (typeof object.abandonPetReq !== "object")
                    throw TypeError(".protoCmd.Request.abandonPetReq: object expected");
                message.abandonPetReq = $root.protoCmd.abandonPetReq.fromObject(object.abandonPetReq);
            }
            if (object.allPetCareReq != null) {
                if (typeof object.allPetCareReq !== "object")
                    throw TypeError(".protoCmd.Request.allPetCareReq: object expected");
                message.allPetCareReq = $root.protoCmd.allPetCareReq.fromObject(object.allPetCareReq);
            }
            if (object.petOperateReq != null) {
                if (typeof object.petOperateReq !== "object")
                    throw TypeError(".protoCmd.Request.petOperateReq: object expected");
                message.petOperateReq = $root.protoCmd.petOperateReq.fromObject(object.petOperateReq);
            }
            if (object.changeUserNameReq != null) {
                if (typeof object.changeUserNameReq !== "object")
                    throw TypeError(".protoCmd.Request.changeUserNameReq: object expected");
                message.changeUserNameReq = $root.protoCmd.changeUserNameReq.fromObject(object.changeUserNameReq);
            }
            if (object.petNameChangeReq != null) {
                if (typeof object.petNameChangeReq !== "object")
                    throw TypeError(".protoCmd.Request.petNameChangeReq: object expected");
                message.petNameChangeReq = $root.protoCmd.petNameChangeReq.fromObject(object.petNameChangeReq);
            }
            if (object.petExpReq != null) {
                if (typeof object.petExpReq !== "object")
                    throw TypeError(".protoCmd.Request.petExpReq: object expected");
                message.petExpReq = $root.protoCmd.petExpReq.fromObject(object.petExpReq);
            }
            if (object.maintenanceReq != null) {
                if (typeof object.maintenanceReq !== "object")
                    throw TypeError(".protoCmd.Request.maintenanceReq: object expected");
                message.maintenanceReq = $root.protoCmd.maintenanceReq.fromObject(object.maintenanceReq);
            }
            if (object.wanderPetAbandonReq != null) {
                if (typeof object.wanderPetAbandonReq !== "object")
                    throw TypeError(".protoCmd.Request.wanderPetAbandonReq: object expected");
                message.wanderPetAbandonReq = $root.protoCmd.wanderPetAbandonReq.fromObject(object.wanderPetAbandonReq);
            }
            if (object.wanderPetAdoptReq != null) {
                if (typeof object.wanderPetAdoptReq !== "object")
                    throw TypeError(".protoCmd.Request.wanderPetAdoptReq: object expected");
                message.wanderPetAdoptReq = $root.protoCmd.wanderPetAdoptReq.fromObject(object.wanderPetAdoptReq);
            }
            if (object.addPetWaterReq != null) {
                if (typeof object.addPetWaterReq !== "object")
                    throw TypeError(".protoCmd.Request.addPetWaterReq: object expected");
                message.addPetWaterReq = $root.protoCmd.addPetWaterReq.fromObject(object.addPetWaterReq);
            }
            if (object.addPetFoodReq != null) {
                if (typeof object.addPetFoodReq !== "object")
                    throw TypeError(".protoCmd.Request.addPetFoodReq: object expected");
                message.addPetFoodReq = $root.protoCmd.addPetFoodReq.fromObject(object.addPetFoodReq);
            }
            if (object.addPetWaterMaxReq != null) {
                if (typeof object.addPetWaterMaxReq !== "object")
                    throw TypeError(".protoCmd.Request.addPetWaterMaxReq: object expected");
                message.addPetWaterMaxReq = $root.protoCmd.addPetWaterMaxReq.fromObject(object.addPetWaterMaxReq);
            }
            if (object.addPetFoodMaxReq != null) {
                if (typeof object.addPetFoodMaxReq !== "object")
                    throw TypeError(".protoCmd.Request.addPetFoodMaxReq: object expected");
                message.addPetFoodMaxReq = $root.protoCmd.addPetFoodMaxReq.fromObject(object.addPetFoodMaxReq);
            }
            if (object.globalHeartPing != null) {
                if (typeof object.globalHeartPing !== "object")
                    throw TypeError(".protoCmd.Request.globalHeartPing: object expected");
                message.globalHeartPing = $root.protoCmd.globalHeartPing.fromObject(object.globalHeartPing);
            }
            if (object.taskreq != null) {
                if (typeof object.taskreq !== "object")
                    throw TypeError(".protoCmd.Request.taskreq: object expected");
                message.taskreq = $root.protoCmd.taskreq.fromObject(object.taskreq);
            }
            if (object.taskBoxreq != null) {
                if (typeof object.taskBoxreq !== "object")
                    throw TypeError(".protoCmd.Request.taskBoxreq: object expected");
                message.taskBoxreq = $root.protoCmd.taskBoxreq.fromObject(object.taskBoxreq);
            }
            if (object.getReardHitReq != null) {
                if (typeof object.getReardHitReq !== "object")
                    throw TypeError(".protoCmd.Request.getReardHitReq: object expected");
                message.getReardHitReq = $root.protoCmd.getReardHitReq.fromObject(object.getReardHitReq);
            }
            if (object.sendGmReq != null) {
                if (typeof object.sendGmReq !== "object")
                    throw TypeError(".protoCmd.Request.sendGmReq: object expected");
                message.sendGmReq = $root.protoCmd.sendGmReq.fromObject(object.sendGmReq);
            }
            if (object.sidebarRewardReq != null) {
                if (typeof object.sidebarRewardReq !== "object")
                    throw TypeError(".protoCmd.Request.sidebarRewardReq: object expected");
                message.sidebarRewardReq = $root.protoCmd.sidebarRewardReq.fromObject(object.sidebarRewardReq);
            }
            if (object.cdkUseReq != null) {
                if (typeof object.cdkUseReq !== "object")
                    throw TypeError(".protoCmd.Request.cdkUseReq: object expected");
                message.cdkUseReq = $root.protoCmd.cdkUseReq.fromObject(object.cdkUseReq);
            }
            if (object.getCutPowerReq != null) {
                if (typeof object.getCutPowerReq !== "object")
                    throw TypeError(".protoCmd.Request.getCutPowerReq: object expected");
                message.getCutPowerReq = $root.protoCmd.getCutPowerReq.fromObject(object.getCutPowerReq);
            }
            if (object.mailSingleReq != null) {
                if (typeof object.mailSingleReq !== "object")
                    throw TypeError(".protoCmd.Request.mailSingleReq: object expected");
                message.mailSingleReq = $root.protoCmd.mailSingleReq.fromObject(object.mailSingleReq);
            }
            if (object.mailRewardReq != null) {
                if (typeof object.mailRewardReq !== "object")
                    throw TypeError(".protoCmd.Request.mailRewardReq: object expected");
                message.mailRewardReq = $root.protoCmd.mailRewardReq.fromObject(object.mailRewardReq);
            }
            if (object.mailAllReq != null) {
                if (typeof object.mailAllReq !== "object")
                    throw TypeError(".protoCmd.Request.mailAllReq: object expected");
                message.mailAllReq = $root.protoCmd.mailAllReq.fromObject(object.mailAllReq);
            }
            if (object.mailDelAllReq != null) {
                if (typeof object.mailDelAllReq !== "object")
                    throw TypeError(".protoCmd.Request.mailDelAllReq: object expected");
                message.mailDelAllReq = $root.protoCmd.mailDelAllReq.fromObject(object.mailDelAllReq);
            }
            if (object.friendReq != null) {
                if (typeof object.friendReq !== "object")
                    throw TypeError(".protoCmd.Request.friendReq: object expected");
                message.friendReq = $root.protoCmd.friendReq.fromObject(object.friendReq);
            }
            if (object.friendAddReq != null) {
                if (typeof object.friendAddReq !== "object")
                    throw TypeError(".protoCmd.Request.friendAddReq: object expected");
                message.friendAddReq = $root.protoCmd.friendAddReq.fromObject(object.friendAddReq);
            }
            if (object.friendDelReq != null) {
                if (typeof object.friendDelReq !== "object")
                    throw TypeError(".protoCmd.Request.friendDelReq: object expected");
                message.friendDelReq = $root.protoCmd.friendDelReq.fromObject(object.friendDelReq);
            }
            if (object.tempFriendReq != null) {
                if (typeof object.tempFriendReq !== "object")
                    throw TypeError(".protoCmd.Request.tempFriendReq: object expected");
                message.tempFriendReq = $root.protoCmd.tempFriendReq.fromObject(object.tempFriendReq);
            }
            if (object.addTempFriendReq != null) {
                if (typeof object.addTempFriendReq !== "object")
                    throw TypeError(".protoCmd.Request.addTempFriendReq: object expected");
                message.addTempFriendReq = $root.protoCmd.addTempFriendReq.fromObject(object.addTempFriendReq);
            }
            if (object.searchFriendReq != null) {
                if (typeof object.searchFriendReq !== "object")
                    throw TypeError(".protoCmd.Request.searchFriendReq: object expected");
                message.searchFriendReq = $root.protoCmd.searchFriendReq.fromObject(object.searchFriendReq);
            }
            return message;
        };

        /**
         * Creates a plain object from a Request message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.Request
         * @static
         * @param {protoCmd.Request} message Request
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        Request.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                object.loginReq = null;
                object.getAllPetReq = null;
                object.getPetReq = null;
                object.commodityReq = null;
                object.changeHeadReq = null;
                object.abandonPetReq = null;
                object.allPetCareReq = null;
                object.petOperateReq = null;
                object.changeUserNameReq = null;
                object.petNameChangeReq = null;
                object.petExpReq = null;
                object.maintenanceReq = null;
                object.wanderPetAbandonReq = null;
                object.wanderPetAdoptReq = null;
                object.addPetWaterReq = null;
                object.addPetFoodReq = null;
                object.addPetWaterMaxReq = null;
                object.addPetFoodMaxReq = null;
                object.globalHeartPing = null;
                object.taskreq = null;
                object.taskBoxreq = null;
                object.getReardHitReq = null;
                object.sendGmReq = null;
                object.sidebarRewardReq = null;
                object.cdkUseReq = null;
                object.getCutPowerReq = null;
                object.mailSingleReq = null;
                object.mailRewardReq = null;
                object.mailAllReq = null;
                object.mailDelAllReq = null;
                object.friendReq = null;
                object.friendAddReq = null;
                object.friendDelReq = null;
                object.tempFriendReq = null;
                object.addTempFriendReq = null;
                object.searchFriendReq = null;
            }
            if (message.loginReq != null && message.hasOwnProperty("loginReq"))
                object.loginReq = $root.protoCmd.loginReq.toObject(message.loginReq, options);
            if (message.getAllPetReq != null && message.hasOwnProperty("getAllPetReq"))
                object.getAllPetReq = $root.protoCmd.getAllPetReq.toObject(message.getAllPetReq, options);
            if (message.getPetReq != null && message.hasOwnProperty("getPetReq"))
                object.getPetReq = $root.protoCmd.getPetReq.toObject(message.getPetReq, options);
            if (message.commodityReq != null && message.hasOwnProperty("commodityReq"))
                object.commodityReq = $root.protoCmd.commodityReq.toObject(message.commodityReq, options);
            if (message.changeHeadReq != null && message.hasOwnProperty("changeHeadReq"))
                object.changeHeadReq = $root.protoCmd.changeHeadReq.toObject(message.changeHeadReq, options);
            if (message.abandonPetReq != null && message.hasOwnProperty("abandonPetReq"))
                object.abandonPetReq = $root.protoCmd.abandonPetReq.toObject(message.abandonPetReq, options);
            if (message.allPetCareReq != null && message.hasOwnProperty("allPetCareReq"))
                object.allPetCareReq = $root.protoCmd.allPetCareReq.toObject(message.allPetCareReq, options);
            if (message.petOperateReq != null && message.hasOwnProperty("petOperateReq"))
                object.petOperateReq = $root.protoCmd.petOperateReq.toObject(message.petOperateReq, options);
            if (message.changeUserNameReq != null && message.hasOwnProperty("changeUserNameReq"))
                object.changeUserNameReq = $root.protoCmd.changeUserNameReq.toObject(message.changeUserNameReq, options);
            if (message.petNameChangeReq != null && message.hasOwnProperty("petNameChangeReq"))
                object.petNameChangeReq = $root.protoCmd.petNameChangeReq.toObject(message.petNameChangeReq, options);
            if (message.petExpReq != null && message.hasOwnProperty("petExpReq"))
                object.petExpReq = $root.protoCmd.petExpReq.toObject(message.petExpReq, options);
            if (message.maintenanceReq != null && message.hasOwnProperty("maintenanceReq"))
                object.maintenanceReq = $root.protoCmd.maintenanceReq.toObject(message.maintenanceReq, options);
            if (message.wanderPetAbandonReq != null && message.hasOwnProperty("wanderPetAbandonReq"))
                object.wanderPetAbandonReq = $root.protoCmd.wanderPetAbandonReq.toObject(message.wanderPetAbandonReq, options);
            if (message.wanderPetAdoptReq != null && message.hasOwnProperty("wanderPetAdoptReq"))
                object.wanderPetAdoptReq = $root.protoCmd.wanderPetAdoptReq.toObject(message.wanderPetAdoptReq, options);
            if (message.addPetWaterReq != null && message.hasOwnProperty("addPetWaterReq"))
                object.addPetWaterReq = $root.protoCmd.addPetWaterReq.toObject(message.addPetWaterReq, options);
            if (message.addPetFoodReq != null && message.hasOwnProperty("addPetFoodReq"))
                object.addPetFoodReq = $root.protoCmd.addPetFoodReq.toObject(message.addPetFoodReq, options);
            if (message.addPetWaterMaxReq != null && message.hasOwnProperty("addPetWaterMaxReq"))
                object.addPetWaterMaxReq = $root.protoCmd.addPetWaterMaxReq.toObject(message.addPetWaterMaxReq, options);
            if (message.addPetFoodMaxReq != null && message.hasOwnProperty("addPetFoodMaxReq"))
                object.addPetFoodMaxReq = $root.protoCmd.addPetFoodMaxReq.toObject(message.addPetFoodMaxReq, options);
            if (message.globalHeartPing != null && message.hasOwnProperty("globalHeartPing"))
                object.globalHeartPing = $root.protoCmd.globalHeartPing.toObject(message.globalHeartPing, options);
            if (message.taskreq != null && message.hasOwnProperty("taskreq"))
                object.taskreq = $root.protoCmd.taskreq.toObject(message.taskreq, options);
            if (message.taskBoxreq != null && message.hasOwnProperty("taskBoxreq"))
                object.taskBoxreq = $root.protoCmd.taskBoxreq.toObject(message.taskBoxreq, options);
            if (message.getReardHitReq != null && message.hasOwnProperty("getReardHitReq"))
                object.getReardHitReq = $root.protoCmd.getReardHitReq.toObject(message.getReardHitReq, options);
            if (message.sendGmReq != null && message.hasOwnProperty("sendGmReq"))
                object.sendGmReq = $root.protoCmd.sendGmReq.toObject(message.sendGmReq, options);
            if (message.sidebarRewardReq != null && message.hasOwnProperty("sidebarRewardReq"))
                object.sidebarRewardReq = $root.protoCmd.sidebarRewardReq.toObject(message.sidebarRewardReq, options);
            if (message.cdkUseReq != null && message.hasOwnProperty("cdkUseReq"))
                object.cdkUseReq = $root.protoCmd.cdkUseReq.toObject(message.cdkUseReq, options);
            if (message.getCutPowerReq != null && message.hasOwnProperty("getCutPowerReq"))
                object.getCutPowerReq = $root.protoCmd.getCutPowerReq.toObject(message.getCutPowerReq, options);
            if (message.mailSingleReq != null && message.hasOwnProperty("mailSingleReq"))
                object.mailSingleReq = $root.protoCmd.mailSingleReq.toObject(message.mailSingleReq, options);
            if (message.mailRewardReq != null && message.hasOwnProperty("mailRewardReq"))
                object.mailRewardReq = $root.protoCmd.mailRewardReq.toObject(message.mailRewardReq, options);
            if (message.mailAllReq != null && message.hasOwnProperty("mailAllReq"))
                object.mailAllReq = $root.protoCmd.mailAllReq.toObject(message.mailAllReq, options);
            if (message.mailDelAllReq != null && message.hasOwnProperty("mailDelAllReq"))
                object.mailDelAllReq = $root.protoCmd.mailDelAllReq.toObject(message.mailDelAllReq, options);
            if (message.friendReq != null && message.hasOwnProperty("friendReq"))
                object.friendReq = $root.protoCmd.friendReq.toObject(message.friendReq, options);
            if (message.friendAddReq != null && message.hasOwnProperty("friendAddReq"))
                object.friendAddReq = $root.protoCmd.friendAddReq.toObject(message.friendAddReq, options);
            if (message.friendDelReq != null && message.hasOwnProperty("friendDelReq"))
                object.friendDelReq = $root.protoCmd.friendDelReq.toObject(message.friendDelReq, options);
            if (message.tempFriendReq != null && message.hasOwnProperty("tempFriendReq"))
                object.tempFriendReq = $root.protoCmd.tempFriendReq.toObject(message.tempFriendReq, options);
            if (message.addTempFriendReq != null && message.hasOwnProperty("addTempFriendReq"))
                object.addTempFriendReq = $root.protoCmd.addTempFriendReq.toObject(message.addTempFriendReq, options);
            if (message.searchFriendReq != null && message.hasOwnProperty("searchFriendReq"))
                object.searchFriendReq = $root.protoCmd.searchFriendReq.toObject(message.searchFriendReq, options);
            return object;
        };

        /**
         * Converts this Request to JSON.
         * @function toJSON
         * @memberof protoCmd.Request
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        Request.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return Request;
    })();

    protoCmd.loginReq = (function() {

        /**
         * Properties of a loginReq.
         * @memberof protoCmd
         * @interface IloginReq
         * @property {string|null} [token] loginReq token
         * @property {number|Long|null} [sign] loginReq sign
         * @property {number|Long|null} [uid] loginReq uid
         * @property {number|null} [server] loginReq server
         */

        /**
         * Constructs a new loginReq.
         * @memberof protoCmd
         * @classdesc Represents a loginReq.
         * @implements IloginReq
         * @constructor
         * @param {protoCmd.IloginReq=} [properties] Properties to set
         */
        function loginReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * loginReq token.
         * @member {string} token
         * @memberof protoCmd.loginReq
         * @instance
         */
        loginReq.prototype.token = "";

        /**
         * loginReq sign.
         * @member {number|Long} sign
         * @memberof protoCmd.loginReq
         * @instance
         */
        loginReq.prototype.sign = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * loginReq uid.
         * @member {number|Long} uid
         * @memberof protoCmd.loginReq
         * @instance
         */
        loginReq.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * loginReq server.
         * @member {number} server
         * @memberof protoCmd.loginReq
         * @instance
         */
        loginReq.prototype.server = 0;

        /**
         * Creates a new loginReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.loginReq
         * @static
         * @param {protoCmd.IloginReq=} [properties] Properties to set
         * @returns {protoCmd.loginReq} loginReq instance
         */
        loginReq.create = function create(properties) {
            return new loginReq(properties);
        };

        /**
         * Encodes the specified loginReq message. Does not implicitly {@link protoCmd.loginReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.loginReq
         * @static
         * @param {protoCmd.IloginReq} message loginReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        loginReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.token != null && Object.hasOwnProperty.call(message, "token"))
                writer.uint32(/* id 1, wireType 2 =*/10).string(message.token);
            if (message.sign != null && Object.hasOwnProperty.call(message, "sign"))
                writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.sign);
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 3, wireType 0 =*/24).uint64(message.uid);
            if (message.server != null && Object.hasOwnProperty.call(message, "server"))
                writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.server);
            return writer;
        };

        /**
         * Encodes the specified loginReq message, length delimited. Does not implicitly {@link protoCmd.loginReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.loginReq
         * @static
         * @param {protoCmd.IloginReq} message loginReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        loginReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a loginReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.loginReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.loginReq} loginReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        loginReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.loginReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.token = reader.string();
                    break;
                case 2:
                    message.sign = reader.uint64();
                    break;
                case 3:
                    message.uid = reader.uint64();
                    break;
                case 4:
                    message.server = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a loginReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.loginReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.loginReq} loginReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        loginReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a loginReq message.
         * @function verify
         * @memberof protoCmd.loginReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        loginReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.token != null && message.hasOwnProperty("token"))
                if (!$util.isString(message.token))
                    return "token: string expected";
            if (message.sign != null && message.hasOwnProperty("sign"))
                if (!$util.isInteger(message.sign) && !(message.sign && $util.isInteger(message.sign.low) && $util.isInteger(message.sign.high)))
                    return "sign: integer|Long expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            if (message.server != null && message.hasOwnProperty("server"))
                if (!$util.isInteger(message.server))
                    return "server: integer expected";
            return null;
        };

        /**
         * Creates a loginReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.loginReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.loginReq} loginReq
         */
        loginReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.loginReq)
                return object;
            var message = new $root.protoCmd.loginReq();
            if (object.token != null)
                message.token = String(object.token);
            if (object.sign != null)
                if ($util.Long)
                    (message.sign = $util.Long.fromValue(object.sign)).unsigned = true;
                else if (typeof object.sign === "string")
                    message.sign = parseInt(object.sign, 10);
                else if (typeof object.sign === "number")
                    message.sign = object.sign;
                else if (typeof object.sign === "object")
                    message.sign = new $util.LongBits(object.sign.low >>> 0, object.sign.high >>> 0).toNumber(true);
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            if (object.server != null)
                message.server = object.server >>> 0;
            return message;
        };

        /**
         * Creates a plain object from a loginReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.loginReq
         * @static
         * @param {protoCmd.loginReq} message loginReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        loginReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                object.token = "";
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.sign = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.sign = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
                object.server = 0;
            }
            if (message.token != null && message.hasOwnProperty("token"))
                object.token = message.token;
            if (message.sign != null && message.hasOwnProperty("sign"))
                if (typeof message.sign === "number")
                    object.sign = options.longs === String ? String(message.sign) : message.sign;
                else
                    object.sign = options.longs === String ? $util.Long.prototype.toString.call(message.sign) : options.longs === Number ? new $util.LongBits(message.sign.low >>> 0, message.sign.high >>> 0).toNumber(true) : message.sign;
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            if (message.server != null && message.hasOwnProperty("server"))
                object.server = message.server;
            return object;
        };

        /**
         * Converts this loginReq to JSON.
         * @function toJSON
         * @memberof protoCmd.loginReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        loginReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return loginReq;
    })();

    protoCmd.loginRes = (function() {

        /**
         * Properties of a loginRes.
         * @memberof protoCmd
         * @interface IloginRes
         * @property {number|Long|null} [uid] loginRes uid
         * @property {number|Long|null} [sign] loginRes sign
         * @property {number|null} [server] loginRes server
         */

        /**
         * Constructs a new loginRes.
         * @memberof protoCmd
         * @classdesc Represents a loginRes.
         * @implements IloginRes
         * @constructor
         * @param {protoCmd.IloginRes=} [properties] Properties to set
         */
        function loginRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * loginRes uid.
         * @member {number|Long} uid
         * @memberof protoCmd.loginRes
         * @instance
         */
        loginRes.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * loginRes sign.
         * @member {number|Long} sign
         * @memberof protoCmd.loginRes
         * @instance
         */
        loginRes.prototype.sign = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * loginRes server.
         * @member {number} server
         * @memberof protoCmd.loginRes
         * @instance
         */
        loginRes.prototype.server = 0;

        /**
         * Creates a new loginRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.loginRes
         * @static
         * @param {protoCmd.IloginRes=} [properties] Properties to set
         * @returns {protoCmd.loginRes} loginRes instance
         */
        loginRes.create = function create(properties) {
            return new loginRes(properties);
        };

        /**
         * Encodes the specified loginRes message. Does not implicitly {@link protoCmd.loginRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.loginRes
         * @static
         * @param {protoCmd.IloginRes} message loginRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        loginRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            if (message.sign != null && Object.hasOwnProperty.call(message, "sign"))
                writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.sign);
            if (message.server != null && Object.hasOwnProperty.call(message, "server"))
                writer.uint32(/* id 3, wireType 0 =*/24).uint32(message.server);
            return writer;
        };

        /**
         * Encodes the specified loginRes message, length delimited. Does not implicitly {@link protoCmd.loginRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.loginRes
         * @static
         * @param {protoCmd.IloginRes} message loginRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        loginRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a loginRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.loginRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.loginRes} loginRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        loginRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.loginRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                case 2:
                    message.sign = reader.uint64();
                    break;
                case 3:
                    message.server = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a loginRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.loginRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.loginRes} loginRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        loginRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a loginRes message.
         * @function verify
         * @memberof protoCmd.loginRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        loginRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            if (message.sign != null && message.hasOwnProperty("sign"))
                if (!$util.isInteger(message.sign) && !(message.sign && $util.isInteger(message.sign.low) && $util.isInteger(message.sign.high)))
                    return "sign: integer|Long expected";
            if (message.server != null && message.hasOwnProperty("server"))
                if (!$util.isInteger(message.server))
                    return "server: integer expected";
            return null;
        };

        /**
         * Creates a loginRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.loginRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.loginRes} loginRes
         */
        loginRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.loginRes)
                return object;
            var message = new $root.protoCmd.loginRes();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            if (object.sign != null)
                if ($util.Long)
                    (message.sign = $util.Long.fromValue(object.sign)).unsigned = true;
                else if (typeof object.sign === "string")
                    message.sign = parseInt(object.sign, 10);
                else if (typeof object.sign === "number")
                    message.sign = object.sign;
                else if (typeof object.sign === "object")
                    message.sign = new $util.LongBits(object.sign.low >>> 0, object.sign.high >>> 0).toNumber(true);
            if (object.server != null)
                message.server = object.server >>> 0;
            return message;
        };

        /**
         * Creates a plain object from a loginRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.loginRes
         * @static
         * @param {protoCmd.loginRes} message loginRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        loginRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.sign = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.sign = options.longs === String ? "0" : 0;
                object.server = 0;
            }
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            if (message.sign != null && message.hasOwnProperty("sign"))
                if (typeof message.sign === "number")
                    object.sign = options.longs === String ? String(message.sign) : message.sign;
                else
                    object.sign = options.longs === String ? $util.Long.prototype.toString.call(message.sign) : options.longs === Number ? new $util.LongBits(message.sign.low >>> 0, message.sign.high >>> 0).toNumber(true) : message.sign;
            if (message.server != null && message.hasOwnProperty("server"))
                object.server = message.server;
            return object;
        };

        /**
         * Converts this loginRes to JSON.
         * @function toJSON
         * @memberof protoCmd.loginRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        loginRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return loginRes;
    })();

    protoCmd.getAllPetReq = (function() {

        /**
         * Properties of a getAllPetReq.
         * @memberof protoCmd
         * @interface IgetAllPetReq
         */

        /**
         * Constructs a new getAllPetReq.
         * @memberof protoCmd
         * @classdesc Represents a getAllPetReq.
         * @implements IgetAllPetReq
         * @constructor
         * @param {protoCmd.IgetAllPetReq=} [properties] Properties to set
         */
        function getAllPetReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new getAllPetReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.getAllPetReq
         * @static
         * @param {protoCmd.IgetAllPetReq=} [properties] Properties to set
         * @returns {protoCmd.getAllPetReq} getAllPetReq instance
         */
        getAllPetReq.create = function create(properties) {
            return new getAllPetReq(properties);
        };

        /**
         * Encodes the specified getAllPetReq message. Does not implicitly {@link protoCmd.getAllPetReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.getAllPetReq
         * @static
         * @param {protoCmd.IgetAllPetReq} message getAllPetReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getAllPetReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified getAllPetReq message, length delimited. Does not implicitly {@link protoCmd.getAllPetReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.getAllPetReq
         * @static
         * @param {protoCmd.IgetAllPetReq} message getAllPetReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getAllPetReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a getAllPetReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.getAllPetReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.getAllPetReq} getAllPetReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getAllPetReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.getAllPetReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a getAllPetReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.getAllPetReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.getAllPetReq} getAllPetReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getAllPetReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a getAllPetReq message.
         * @function verify
         * @memberof protoCmd.getAllPetReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        getAllPetReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates a getAllPetReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.getAllPetReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.getAllPetReq} getAllPetReq
         */
        getAllPetReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.getAllPetReq)
                return object;
            return new $root.protoCmd.getAllPetReq();
        };

        /**
         * Creates a plain object from a getAllPetReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.getAllPetReq
         * @static
         * @param {protoCmd.getAllPetReq} message getAllPetReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        getAllPetReq.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this getAllPetReq to JSON.
         * @function toJSON
         * @memberof protoCmd.getAllPetReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        getAllPetReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return getAllPetReq;
    })();

    protoCmd.getAllPetRes = (function() {

        /**
         * Properties of a getAllPetRes.
         * @memberof protoCmd
         * @interface IgetAllPetRes
         * @property {Array.<protoCmd.IgetPetRes>|null} [petList] getAllPetRes petList
         */

        /**
         * Constructs a new getAllPetRes.
         * @memberof protoCmd
         * @classdesc Represents a getAllPetRes.
         * @implements IgetAllPetRes
         * @constructor
         * @param {protoCmd.IgetAllPetRes=} [properties] Properties to set
         */
        function getAllPetRes(properties) {
            this.petList = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * getAllPetRes petList.
         * @member {Array.<protoCmd.IgetPetRes>} petList
         * @memberof protoCmd.getAllPetRes
         * @instance
         */
        getAllPetRes.prototype.petList = $util.emptyArray;

        /**
         * Creates a new getAllPetRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.getAllPetRes
         * @static
         * @param {protoCmd.IgetAllPetRes=} [properties] Properties to set
         * @returns {protoCmd.getAllPetRes} getAllPetRes instance
         */
        getAllPetRes.create = function create(properties) {
            return new getAllPetRes(properties);
        };

        /**
         * Encodes the specified getAllPetRes message. Does not implicitly {@link protoCmd.getAllPetRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.getAllPetRes
         * @static
         * @param {protoCmd.IgetAllPetRes} message getAllPetRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getAllPetRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.petList != null && message.petList.length)
                for (var i = 0; i < message.petList.length; ++i)
                    $root.protoCmd.getPetRes.encode(message.petList[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified getAllPetRes message, length delimited. Does not implicitly {@link protoCmd.getAllPetRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.getAllPetRes
         * @static
         * @param {protoCmd.IgetAllPetRes} message getAllPetRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getAllPetRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a getAllPetRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.getAllPetRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.getAllPetRes} getAllPetRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getAllPetRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.getAllPetRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    if (!(message.petList && message.petList.length))
                        message.petList = [];
                    message.petList.push($root.protoCmd.getPetRes.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a getAllPetRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.getAllPetRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.getAllPetRes} getAllPetRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getAllPetRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a getAllPetRes message.
         * @function verify
         * @memberof protoCmd.getAllPetRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        getAllPetRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.petList != null && message.hasOwnProperty("petList")) {
                if (!Array.isArray(message.petList))
                    return "petList: array expected";
                for (var i = 0; i < message.petList.length; ++i) {
                    var error = $root.protoCmd.getPetRes.verify(message.petList[i]);
                    if (error)
                        return "petList." + error;
                }
            }
            return null;
        };

        /**
         * Creates a getAllPetRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.getAllPetRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.getAllPetRes} getAllPetRes
         */
        getAllPetRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.getAllPetRes)
                return object;
            var message = new $root.protoCmd.getAllPetRes();
            if (object.petList) {
                if (!Array.isArray(object.petList))
                    throw TypeError(".protoCmd.getAllPetRes.petList: array expected");
                message.petList = [];
                for (var i = 0; i < object.petList.length; ++i) {
                    if (typeof object.petList[i] !== "object")
                        throw TypeError(".protoCmd.getAllPetRes.petList: object expected");
                    message.petList[i] = $root.protoCmd.getPetRes.fromObject(object.petList[i]);
                }
            }
            return message;
        };

        /**
         * Creates a plain object from a getAllPetRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.getAllPetRes
         * @static
         * @param {protoCmd.getAllPetRes} message getAllPetRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        getAllPetRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.arrays || options.defaults)
                object.petList = [];
            if (message.petList && message.petList.length) {
                object.petList = [];
                for (var j = 0; j < message.petList.length; ++j)
                    object.petList[j] = $root.protoCmd.getPetRes.toObject(message.petList[j], options);
            }
            return object;
        };

        /**
         * Converts this getAllPetRes to JSON.
         * @function toJSON
         * @memberof protoCmd.getAllPetRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        getAllPetRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return getAllPetRes;
    })();

    protoCmd.getPetReq = (function() {

        /**
         * Properties of a getPetReq.
         * @memberof protoCmd
         * @interface IgetPetReq
         * @property {number|Long|null} [uid] getPetReq uid
         */

        /**
         * Constructs a new getPetReq.
         * @memberof protoCmd
         * @classdesc Represents a getPetReq.
         * @implements IgetPetReq
         * @constructor
         * @param {protoCmd.IgetPetReq=} [properties] Properties to set
         */
        function getPetReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * getPetReq uid.
         * @member {number|Long} uid
         * @memberof protoCmd.getPetReq
         * @instance
         */
        getPetReq.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new getPetReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.getPetReq
         * @static
         * @param {protoCmd.IgetPetReq=} [properties] Properties to set
         * @returns {protoCmd.getPetReq} getPetReq instance
         */
        getPetReq.create = function create(properties) {
            return new getPetReq(properties);
        };

        /**
         * Encodes the specified getPetReq message. Does not implicitly {@link protoCmd.getPetReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.getPetReq
         * @static
         * @param {protoCmd.IgetPetReq} message getPetReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getPetReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            return writer;
        };

        /**
         * Encodes the specified getPetReq message, length delimited. Does not implicitly {@link protoCmd.getPetReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.getPetReq
         * @static
         * @param {protoCmd.IgetPetReq} message getPetReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getPetReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a getPetReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.getPetReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.getPetReq} getPetReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getPetReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.getPetReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a getPetReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.getPetReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.getPetReq} getPetReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getPetReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a getPetReq message.
         * @function verify
         * @memberof protoCmd.getPetReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        getPetReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            return null;
        };

        /**
         * Creates a getPetReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.getPetReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.getPetReq} getPetReq
         */
        getPetReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.getPetReq)
                return object;
            var message = new $root.protoCmd.getPetReq();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a getPetReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.getPetReq
         * @static
         * @param {protoCmd.getPetReq} message getPetReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        getPetReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            return object;
        };

        /**
         * Converts this getPetReq to JSON.
         * @function toJSON
         * @memberof protoCmd.getPetReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        getPetReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return getPetReq;
    })();

    protoCmd.getPetRes = (function() {

        /**
         * Properties of a getPetRes.
         * @memberof protoCmd
         * @interface IgetPetRes
         * @property {number|Long|null} [uid] getPetRes uid
         * @property {number|null} [cid] getPetRes cid
         * @property {string|null} [name] getPetRes name
         * @property {number|null} [exp] getPetRes exp
         * @property {number|null} [from] getPetRes from
         * @property {Array.<protoCmd.IattrDict>|null} [attr] getPetRes attr
         */

        /**
         * Constructs a new getPetRes.
         * @memberof protoCmd
         * @classdesc Represents a getPetRes.
         * @implements IgetPetRes
         * @constructor
         * @param {protoCmd.IgetPetRes=} [properties] Properties to set
         */
        function getPetRes(properties) {
            this.attr = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * getPetRes uid.
         * @member {number|Long} uid
         * @memberof protoCmd.getPetRes
         * @instance
         */
        getPetRes.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * getPetRes cid.
         * @member {number} cid
         * @memberof protoCmd.getPetRes
         * @instance
         */
        getPetRes.prototype.cid = 0;

        /**
         * getPetRes name.
         * @member {string} name
         * @memberof protoCmd.getPetRes
         * @instance
         */
        getPetRes.prototype.name = "";

        /**
         * getPetRes exp.
         * @member {number} exp
         * @memberof protoCmd.getPetRes
         * @instance
         */
        getPetRes.prototype.exp = 0;

        /**
         * getPetRes from.
         * @member {number} from
         * @memberof protoCmd.getPetRes
         * @instance
         */
        getPetRes.prototype.from = 0;

        /**
         * getPetRes attr.
         * @member {Array.<protoCmd.IattrDict>} attr
         * @memberof protoCmd.getPetRes
         * @instance
         */
        getPetRes.prototype.attr = $util.emptyArray;

        /**
         * Creates a new getPetRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.getPetRes
         * @static
         * @param {protoCmd.IgetPetRes=} [properties] Properties to set
         * @returns {protoCmd.getPetRes} getPetRes instance
         */
        getPetRes.create = function create(properties) {
            return new getPetRes(properties);
        };

        /**
         * Encodes the specified getPetRes message. Does not implicitly {@link protoCmd.getPetRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.getPetRes
         * @static
         * @param {protoCmd.IgetPetRes} message getPetRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getPetRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            if (message.cid != null && Object.hasOwnProperty.call(message, "cid"))
                writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.cid);
            if (message.name != null && Object.hasOwnProperty.call(message, "name"))
                writer.uint32(/* id 3, wireType 2 =*/26).string(message.name);
            if (message.exp != null && Object.hasOwnProperty.call(message, "exp"))
                writer.uint32(/* id 4, wireType 1 =*/33).double(message.exp);
            if (message.from != null && Object.hasOwnProperty.call(message, "from"))
                writer.uint32(/* id 5, wireType 0 =*/40).uint32(message.from);
            if (message.attr != null && message.attr.length)
                for (var i = 0; i < message.attr.length; ++i)
                    $root.protoCmd.attrDict.encode(message.attr[i], writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified getPetRes message, length delimited. Does not implicitly {@link protoCmd.getPetRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.getPetRes
         * @static
         * @param {protoCmd.IgetPetRes} message getPetRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getPetRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a getPetRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.getPetRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.getPetRes} getPetRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getPetRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.getPetRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                case 2:
                    message.cid = reader.uint32();
                    break;
                case 3:
                    message.name = reader.string();
                    break;
                case 4:
                    message.exp = reader.double();
                    break;
                case 5:
                    message.from = reader.uint32();
                    break;
                case 6:
                    if (!(message.attr && message.attr.length))
                        message.attr = [];
                    message.attr.push($root.protoCmd.attrDict.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a getPetRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.getPetRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.getPetRes} getPetRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getPetRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a getPetRes message.
         * @function verify
         * @memberof protoCmd.getPetRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        getPetRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (!$util.isInteger(message.cid))
                    return "cid: integer expected";
            if (message.name != null && message.hasOwnProperty("name"))
                if (!$util.isString(message.name))
                    return "name: string expected";
            if (message.exp != null && message.hasOwnProperty("exp"))
                if (typeof message.exp !== "number")
                    return "exp: number expected";
            if (message.from != null && message.hasOwnProperty("from"))
                if (!$util.isInteger(message.from))
                    return "from: integer expected";
            if (message.attr != null && message.hasOwnProperty("attr")) {
                if (!Array.isArray(message.attr))
                    return "attr: array expected";
                for (var i = 0; i < message.attr.length; ++i) {
                    var error = $root.protoCmd.attrDict.verify(message.attr[i]);
                    if (error)
                        return "attr." + error;
                }
            }
            return null;
        };

        /**
         * Creates a getPetRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.getPetRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.getPetRes} getPetRes
         */
        getPetRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.getPetRes)
                return object;
            var message = new $root.protoCmd.getPetRes();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            if (object.cid != null)
                message.cid = object.cid >>> 0;
            if (object.name != null)
                message.name = String(object.name);
            if (object.exp != null)
                message.exp = Number(object.exp);
            if (object.from != null)
                message.from = object.from >>> 0;
            if (object.attr) {
                if (!Array.isArray(object.attr))
                    throw TypeError(".protoCmd.getPetRes.attr: array expected");
                message.attr = [];
                for (var i = 0; i < object.attr.length; ++i) {
                    if (typeof object.attr[i] !== "object")
                        throw TypeError(".protoCmd.getPetRes.attr: object expected");
                    message.attr[i] = $root.protoCmd.attrDict.fromObject(object.attr[i]);
                }
            }
            return message;
        };

        /**
         * Creates a plain object from a getPetRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.getPetRes
         * @static
         * @param {protoCmd.getPetRes} message getPetRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        getPetRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.arrays || options.defaults)
                object.attr = [];
            if (options.defaults) {
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
                object.cid = 0;
                object.name = "";
                object.exp = 0;
                object.from = 0;
            }
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            if (message.cid != null && message.hasOwnProperty("cid"))
                object.cid = message.cid;
            if (message.name != null && message.hasOwnProperty("name"))
                object.name = message.name;
            if (message.exp != null && message.hasOwnProperty("exp"))
                object.exp = options.json && !isFinite(message.exp) ? String(message.exp) : message.exp;
            if (message.from != null && message.hasOwnProperty("from"))
                object.from = message.from;
            if (message.attr && message.attr.length) {
                object.attr = [];
                for (var j = 0; j < message.attr.length; ++j)
                    object.attr[j] = $root.protoCmd.attrDict.toObject(message.attr[j], options);
            }
            return object;
        };

        /**
         * Converts this getPetRes to JSON.
         * @function toJSON
         * @memberof protoCmd.getPetRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        getPetRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return getPetRes;
    })();

    protoCmd.petNameChangeReq = (function() {

        /**
         * Properties of a petNameChangeReq.
         * @memberof protoCmd
         * @interface IpetNameChangeReq
         * @property {number|Long|null} [uid] petNameChangeReq uid
         * @property {string|null} [name] petNameChangeReq name
         */

        /**
         * Constructs a new petNameChangeReq.
         * @memberof protoCmd
         * @classdesc Represents a petNameChangeReq.
         * @implements IpetNameChangeReq
         * @constructor
         * @param {protoCmd.IpetNameChangeReq=} [properties] Properties to set
         */
        function petNameChangeReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * petNameChangeReq uid.
         * @member {number|Long} uid
         * @memberof protoCmd.petNameChangeReq
         * @instance
         */
        petNameChangeReq.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * petNameChangeReq name.
         * @member {string} name
         * @memberof protoCmd.petNameChangeReq
         * @instance
         */
        petNameChangeReq.prototype.name = "";

        /**
         * Creates a new petNameChangeReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.petNameChangeReq
         * @static
         * @param {protoCmd.IpetNameChangeReq=} [properties] Properties to set
         * @returns {protoCmd.petNameChangeReq} petNameChangeReq instance
         */
        petNameChangeReq.create = function create(properties) {
            return new petNameChangeReq(properties);
        };

        /**
         * Encodes the specified petNameChangeReq message. Does not implicitly {@link protoCmd.petNameChangeReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.petNameChangeReq
         * @static
         * @param {protoCmd.IpetNameChangeReq} message petNameChangeReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        petNameChangeReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            if (message.name != null && Object.hasOwnProperty.call(message, "name"))
                writer.uint32(/* id 2, wireType 2 =*/18).string(message.name);
            return writer;
        };

        /**
         * Encodes the specified petNameChangeReq message, length delimited. Does not implicitly {@link protoCmd.petNameChangeReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.petNameChangeReq
         * @static
         * @param {protoCmd.IpetNameChangeReq} message petNameChangeReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        petNameChangeReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a petNameChangeReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.petNameChangeReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.petNameChangeReq} petNameChangeReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        petNameChangeReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.petNameChangeReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                case 2:
                    message.name = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a petNameChangeReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.petNameChangeReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.petNameChangeReq} petNameChangeReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        petNameChangeReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a petNameChangeReq message.
         * @function verify
         * @memberof protoCmd.petNameChangeReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        petNameChangeReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            if (message.name != null && message.hasOwnProperty("name"))
                if (!$util.isString(message.name))
                    return "name: string expected";
            return null;
        };

        /**
         * Creates a petNameChangeReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.petNameChangeReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.petNameChangeReq} petNameChangeReq
         */
        petNameChangeReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.petNameChangeReq)
                return object;
            var message = new $root.protoCmd.petNameChangeReq();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            if (object.name != null)
                message.name = String(object.name);
            return message;
        };

        /**
         * Creates a plain object from a petNameChangeReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.petNameChangeReq
         * @static
         * @param {protoCmd.petNameChangeReq} message petNameChangeReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        petNameChangeReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
                object.name = "";
            }
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            if (message.name != null && message.hasOwnProperty("name"))
                object.name = message.name;
            return object;
        };

        /**
         * Converts this petNameChangeReq to JSON.
         * @function toJSON
         * @memberof protoCmd.petNameChangeReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        petNameChangeReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return petNameChangeReq;
    })();

    protoCmd.petNameChangeRes = (function() {

        /**
         * Properties of a petNameChangeRes.
         * @memberof protoCmd
         * @interface IpetNameChangeRes
         * @property {number|Long|null} [uid] petNameChangeRes uid
         * @property {string|null} [name] petNameChangeRes name
         */

        /**
         * Constructs a new petNameChangeRes.
         * @memberof protoCmd
         * @classdesc Represents a petNameChangeRes.
         * @implements IpetNameChangeRes
         * @constructor
         * @param {protoCmd.IpetNameChangeRes=} [properties] Properties to set
         */
        function petNameChangeRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * petNameChangeRes uid.
         * @member {number|Long} uid
         * @memberof protoCmd.petNameChangeRes
         * @instance
         */
        petNameChangeRes.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * petNameChangeRes name.
         * @member {string} name
         * @memberof protoCmd.petNameChangeRes
         * @instance
         */
        petNameChangeRes.prototype.name = "";

        /**
         * Creates a new petNameChangeRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.petNameChangeRes
         * @static
         * @param {protoCmd.IpetNameChangeRes=} [properties] Properties to set
         * @returns {protoCmd.petNameChangeRes} petNameChangeRes instance
         */
        petNameChangeRes.create = function create(properties) {
            return new petNameChangeRes(properties);
        };

        /**
         * Encodes the specified petNameChangeRes message. Does not implicitly {@link protoCmd.petNameChangeRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.petNameChangeRes
         * @static
         * @param {protoCmd.IpetNameChangeRes} message petNameChangeRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        petNameChangeRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            if (message.name != null && Object.hasOwnProperty.call(message, "name"))
                writer.uint32(/* id 2, wireType 2 =*/18).string(message.name);
            return writer;
        };

        /**
         * Encodes the specified petNameChangeRes message, length delimited. Does not implicitly {@link protoCmd.petNameChangeRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.petNameChangeRes
         * @static
         * @param {protoCmd.IpetNameChangeRes} message petNameChangeRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        petNameChangeRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a petNameChangeRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.petNameChangeRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.petNameChangeRes} petNameChangeRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        petNameChangeRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.petNameChangeRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                case 2:
                    message.name = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a petNameChangeRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.petNameChangeRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.petNameChangeRes} petNameChangeRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        petNameChangeRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a petNameChangeRes message.
         * @function verify
         * @memberof protoCmd.petNameChangeRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        petNameChangeRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            if (message.name != null && message.hasOwnProperty("name"))
                if (!$util.isString(message.name))
                    return "name: string expected";
            return null;
        };

        /**
         * Creates a petNameChangeRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.petNameChangeRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.petNameChangeRes} petNameChangeRes
         */
        petNameChangeRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.petNameChangeRes)
                return object;
            var message = new $root.protoCmd.petNameChangeRes();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            if (object.name != null)
                message.name = String(object.name);
            return message;
        };

        /**
         * Creates a plain object from a petNameChangeRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.petNameChangeRes
         * @static
         * @param {protoCmd.petNameChangeRes} message petNameChangeRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        petNameChangeRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
                object.name = "";
            }
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            if (message.name != null && message.hasOwnProperty("name"))
                object.name = message.name;
            return object;
        };

        /**
         * Converts this petNameChangeRes to JSON.
         * @function toJSON
         * @memberof protoCmd.petNameChangeRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        petNameChangeRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return petNameChangeRes;
    })();

    protoCmd.abandonPetReq = (function() {

        /**
         * Properties of an abandonPetReq.
         * @memberof protoCmd
         * @interface IabandonPetReq
         * @property {number|Long|null} [uid] abandonPetReq uid
         */

        /**
         * Constructs a new abandonPetReq.
         * @memberof protoCmd
         * @classdesc Represents an abandonPetReq.
         * @implements IabandonPetReq
         * @constructor
         * @param {protoCmd.IabandonPetReq=} [properties] Properties to set
         */
        function abandonPetReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * abandonPetReq uid.
         * @member {number|Long} uid
         * @memberof protoCmd.abandonPetReq
         * @instance
         */
        abandonPetReq.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new abandonPetReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.abandonPetReq
         * @static
         * @param {protoCmd.IabandonPetReq=} [properties] Properties to set
         * @returns {protoCmd.abandonPetReq} abandonPetReq instance
         */
        abandonPetReq.create = function create(properties) {
            return new abandonPetReq(properties);
        };

        /**
         * Encodes the specified abandonPetReq message. Does not implicitly {@link protoCmd.abandonPetReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.abandonPetReq
         * @static
         * @param {protoCmd.IabandonPetReq} message abandonPetReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        abandonPetReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            return writer;
        };

        /**
         * Encodes the specified abandonPetReq message, length delimited. Does not implicitly {@link protoCmd.abandonPetReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.abandonPetReq
         * @static
         * @param {protoCmd.IabandonPetReq} message abandonPetReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        abandonPetReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an abandonPetReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.abandonPetReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.abandonPetReq} abandonPetReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        abandonPetReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.abandonPetReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes an abandonPetReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.abandonPetReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.abandonPetReq} abandonPetReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        abandonPetReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an abandonPetReq message.
         * @function verify
         * @memberof protoCmd.abandonPetReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        abandonPetReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            return null;
        };

        /**
         * Creates an abandonPetReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.abandonPetReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.abandonPetReq} abandonPetReq
         */
        abandonPetReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.abandonPetReq)
                return object;
            var message = new $root.protoCmd.abandonPetReq();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from an abandonPetReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.abandonPetReq
         * @static
         * @param {protoCmd.abandonPetReq} message abandonPetReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        abandonPetReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            return object;
        };

        /**
         * Converts this abandonPetReq to JSON.
         * @function toJSON
         * @memberof protoCmd.abandonPetReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        abandonPetReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return abandonPetReq;
    })();

    protoCmd.abandonPetRes = (function() {

        /**
         * Properties of an abandonPetRes.
         * @memberof protoCmd
         * @interface IabandonPetRes
         * @property {number|Long|null} [uid] abandonPetRes uid
         */

        /**
         * Constructs a new abandonPetRes.
         * @memberof protoCmd
         * @classdesc Represents an abandonPetRes.
         * @implements IabandonPetRes
         * @constructor
         * @param {protoCmd.IabandonPetRes=} [properties] Properties to set
         */
        function abandonPetRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * abandonPetRes uid.
         * @member {number|Long} uid
         * @memberof protoCmd.abandonPetRes
         * @instance
         */
        abandonPetRes.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new abandonPetRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.abandonPetRes
         * @static
         * @param {protoCmd.IabandonPetRes=} [properties] Properties to set
         * @returns {protoCmd.abandonPetRes} abandonPetRes instance
         */
        abandonPetRes.create = function create(properties) {
            return new abandonPetRes(properties);
        };

        /**
         * Encodes the specified abandonPetRes message. Does not implicitly {@link protoCmd.abandonPetRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.abandonPetRes
         * @static
         * @param {protoCmd.IabandonPetRes} message abandonPetRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        abandonPetRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            return writer;
        };

        /**
         * Encodes the specified abandonPetRes message, length delimited. Does not implicitly {@link protoCmd.abandonPetRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.abandonPetRes
         * @static
         * @param {protoCmd.IabandonPetRes} message abandonPetRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        abandonPetRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an abandonPetRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.abandonPetRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.abandonPetRes} abandonPetRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        abandonPetRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.abandonPetRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes an abandonPetRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.abandonPetRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.abandonPetRes} abandonPetRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        abandonPetRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an abandonPetRes message.
         * @function verify
         * @memberof protoCmd.abandonPetRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        abandonPetRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            return null;
        };

        /**
         * Creates an abandonPetRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.abandonPetRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.abandonPetRes} abandonPetRes
         */
        abandonPetRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.abandonPetRes)
                return object;
            var message = new $root.protoCmd.abandonPetRes();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from an abandonPetRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.abandonPetRes
         * @static
         * @param {protoCmd.abandonPetRes} message abandonPetRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        abandonPetRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            return object;
        };

        /**
         * Converts this abandonPetRes to JSON.
         * @function toJSON
         * @memberof protoCmd.abandonPetRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        abandonPetRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return abandonPetRes;
    })();

    protoCmd.allPetCareReq = (function() {

        /**
         * Properties of an allPetCareReq.
         * @memberof protoCmd
         * @interface IallPetCareReq
         */

        /**
         * Constructs a new allPetCareReq.
         * @memberof protoCmd
         * @classdesc Represents an allPetCareReq.
         * @implements IallPetCareReq
         * @constructor
         * @param {protoCmd.IallPetCareReq=} [properties] Properties to set
         */
        function allPetCareReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new allPetCareReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.allPetCareReq
         * @static
         * @param {protoCmd.IallPetCareReq=} [properties] Properties to set
         * @returns {protoCmd.allPetCareReq} allPetCareReq instance
         */
        allPetCareReq.create = function create(properties) {
            return new allPetCareReq(properties);
        };

        /**
         * Encodes the specified allPetCareReq message. Does not implicitly {@link protoCmd.allPetCareReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.allPetCareReq
         * @static
         * @param {protoCmd.IallPetCareReq} message allPetCareReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        allPetCareReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified allPetCareReq message, length delimited. Does not implicitly {@link protoCmd.allPetCareReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.allPetCareReq
         * @static
         * @param {protoCmd.IallPetCareReq} message allPetCareReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        allPetCareReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an allPetCareReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.allPetCareReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.allPetCareReq} allPetCareReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        allPetCareReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.allPetCareReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes an allPetCareReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.allPetCareReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.allPetCareReq} allPetCareReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        allPetCareReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an allPetCareReq message.
         * @function verify
         * @memberof protoCmd.allPetCareReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        allPetCareReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates an allPetCareReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.allPetCareReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.allPetCareReq} allPetCareReq
         */
        allPetCareReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.allPetCareReq)
                return object;
            return new $root.protoCmd.allPetCareReq();
        };

        /**
         * Creates a plain object from an allPetCareReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.allPetCareReq
         * @static
         * @param {protoCmd.allPetCareReq} message allPetCareReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        allPetCareReq.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this allPetCareReq to JSON.
         * @function toJSON
         * @memberof protoCmd.allPetCareReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        allPetCareReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return allPetCareReq;
    })();

    protoCmd.petOperateReq = (function() {

        /**
         * Properties of a petOperateReq.
         * @memberof protoCmd
         * @interface IpetOperateReq
         * @property {number|Long|null} [uid] petOperateReq uid
         * @property {number|null} [cid] petOperateReq cid
         * @property {boolean|null} [ad] petOperateReq ad
         */

        /**
         * Constructs a new petOperateReq.
         * @memberof protoCmd
         * @classdesc Represents a petOperateReq.
         * @implements IpetOperateReq
         * @constructor
         * @param {protoCmd.IpetOperateReq=} [properties] Properties to set
         */
        function petOperateReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * petOperateReq uid.
         * @member {number|Long} uid
         * @memberof protoCmd.petOperateReq
         * @instance
         */
        petOperateReq.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * petOperateReq cid.
         * @member {number} cid
         * @memberof protoCmd.petOperateReq
         * @instance
         */
        petOperateReq.prototype.cid = 0;

        /**
         * petOperateReq ad.
         * @member {boolean} ad
         * @memberof protoCmd.petOperateReq
         * @instance
         */
        petOperateReq.prototype.ad = false;

        /**
         * Creates a new petOperateReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.petOperateReq
         * @static
         * @param {protoCmd.IpetOperateReq=} [properties] Properties to set
         * @returns {protoCmd.petOperateReq} petOperateReq instance
         */
        petOperateReq.create = function create(properties) {
            return new petOperateReq(properties);
        };

        /**
         * Encodes the specified petOperateReq message. Does not implicitly {@link protoCmd.petOperateReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.petOperateReq
         * @static
         * @param {protoCmd.IpetOperateReq} message petOperateReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        petOperateReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            if (message.cid != null && Object.hasOwnProperty.call(message, "cid"))
                writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.cid);
            if (message.ad != null && Object.hasOwnProperty.call(message, "ad"))
                writer.uint32(/* id 3, wireType 0 =*/24).bool(message.ad);
            return writer;
        };

        /**
         * Encodes the specified petOperateReq message, length delimited. Does not implicitly {@link protoCmd.petOperateReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.petOperateReq
         * @static
         * @param {protoCmd.IpetOperateReq} message petOperateReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        petOperateReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a petOperateReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.petOperateReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.petOperateReq} petOperateReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        petOperateReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.petOperateReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                case 2:
                    message.cid = reader.uint32();
                    break;
                case 3:
                    message.ad = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a petOperateReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.petOperateReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.petOperateReq} petOperateReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        petOperateReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a petOperateReq message.
         * @function verify
         * @memberof protoCmd.petOperateReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        petOperateReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (!$util.isInteger(message.cid))
                    return "cid: integer expected";
            if (message.ad != null && message.hasOwnProperty("ad"))
                if (typeof message.ad !== "boolean")
                    return "ad: boolean expected";
            return null;
        };

        /**
         * Creates a petOperateReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.petOperateReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.petOperateReq} petOperateReq
         */
        petOperateReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.petOperateReq)
                return object;
            var message = new $root.protoCmd.petOperateReq();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            if (object.cid != null)
                message.cid = object.cid >>> 0;
            if (object.ad != null)
                message.ad = Boolean(object.ad);
            return message;
        };

        /**
         * Creates a plain object from a petOperateReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.petOperateReq
         * @static
         * @param {protoCmd.petOperateReq} message petOperateReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        petOperateReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
                object.cid = 0;
                object.ad = false;
            }
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            if (message.cid != null && message.hasOwnProperty("cid"))
                object.cid = message.cid;
            if (message.ad != null && message.hasOwnProperty("ad"))
                object.ad = message.ad;
            return object;
        };

        /**
         * Converts this petOperateReq to JSON.
         * @function toJSON
         * @memberof protoCmd.petOperateReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        petOperateReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return petOperateReq;
    })();

    protoCmd.wanderPetSyn = (function() {

        /**
         * Properties of a wanderPetSyn.
         * @memberof protoCmd
         * @interface IwanderPetSyn
         * @property {number|Long|null} [cid] wanderPetSyn cid
         */

        /**
         * Constructs a new wanderPetSyn.
         * @memberof protoCmd
         * @classdesc Represents a wanderPetSyn.
         * @implements IwanderPetSyn
         * @constructor
         * @param {protoCmd.IwanderPetSyn=} [properties] Properties to set
         */
        function wanderPetSyn(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * wanderPetSyn cid.
         * @member {number|Long} cid
         * @memberof protoCmd.wanderPetSyn
         * @instance
         */
        wanderPetSyn.prototype.cid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new wanderPetSyn instance using the specified properties.
         * @function create
         * @memberof protoCmd.wanderPetSyn
         * @static
         * @param {protoCmd.IwanderPetSyn=} [properties] Properties to set
         * @returns {protoCmd.wanderPetSyn} wanderPetSyn instance
         */
        wanderPetSyn.create = function create(properties) {
            return new wanderPetSyn(properties);
        };

        /**
         * Encodes the specified wanderPetSyn message. Does not implicitly {@link protoCmd.wanderPetSyn.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.wanderPetSyn
         * @static
         * @param {protoCmd.IwanderPetSyn} message wanderPetSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        wanderPetSyn.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.cid != null && Object.hasOwnProperty.call(message, "cid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.cid);
            return writer;
        };

        /**
         * Encodes the specified wanderPetSyn message, length delimited. Does not implicitly {@link protoCmd.wanderPetSyn.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.wanderPetSyn
         * @static
         * @param {protoCmd.IwanderPetSyn} message wanderPetSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        wanderPetSyn.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a wanderPetSyn message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.wanderPetSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.wanderPetSyn} wanderPetSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        wanderPetSyn.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.wanderPetSyn();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.cid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a wanderPetSyn message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.wanderPetSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.wanderPetSyn} wanderPetSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        wanderPetSyn.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a wanderPetSyn message.
         * @function verify
         * @memberof protoCmd.wanderPetSyn
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        wanderPetSyn.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (!$util.isInteger(message.cid) && !(message.cid && $util.isInteger(message.cid.low) && $util.isInteger(message.cid.high)))
                    return "cid: integer|Long expected";
            return null;
        };

        /**
         * Creates a wanderPetSyn message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.wanderPetSyn
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.wanderPetSyn} wanderPetSyn
         */
        wanderPetSyn.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.wanderPetSyn)
                return object;
            var message = new $root.protoCmd.wanderPetSyn();
            if (object.cid != null)
                if ($util.Long)
                    (message.cid = $util.Long.fromValue(object.cid)).unsigned = true;
                else if (typeof object.cid === "string")
                    message.cid = parseInt(object.cid, 10);
                else if (typeof object.cid === "number")
                    message.cid = object.cid;
                else if (typeof object.cid === "object")
                    message.cid = new $util.LongBits(object.cid.low >>> 0, object.cid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a wanderPetSyn message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.wanderPetSyn
         * @static
         * @param {protoCmd.wanderPetSyn} message wanderPetSyn
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        wanderPetSyn.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.cid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.cid = options.longs === String ? "0" : 0;
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (typeof message.cid === "number")
                    object.cid = options.longs === String ? String(message.cid) : message.cid;
                else
                    object.cid = options.longs === String ? $util.Long.prototype.toString.call(message.cid) : options.longs === Number ? new $util.LongBits(message.cid.low >>> 0, message.cid.high >>> 0).toNumber(true) : message.cid;
            return object;
        };

        /**
         * Converts this wanderPetSyn to JSON.
         * @function toJSON
         * @memberof protoCmd.wanderPetSyn
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        wanderPetSyn.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return wanderPetSyn;
    })();

    protoCmd.wanderPetAbandonReq = (function() {

        /**
         * Properties of a wanderPetAbandonReq.
         * @memberof protoCmd
         * @interface IwanderPetAbandonReq
         */

        /**
         * Constructs a new wanderPetAbandonReq.
         * @memberof protoCmd
         * @classdesc Represents a wanderPetAbandonReq.
         * @implements IwanderPetAbandonReq
         * @constructor
         * @param {protoCmd.IwanderPetAbandonReq=} [properties] Properties to set
         */
        function wanderPetAbandonReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new wanderPetAbandonReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.wanderPetAbandonReq
         * @static
         * @param {protoCmd.IwanderPetAbandonReq=} [properties] Properties to set
         * @returns {protoCmd.wanderPetAbandonReq} wanderPetAbandonReq instance
         */
        wanderPetAbandonReq.create = function create(properties) {
            return new wanderPetAbandonReq(properties);
        };

        /**
         * Encodes the specified wanderPetAbandonReq message. Does not implicitly {@link protoCmd.wanderPetAbandonReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.wanderPetAbandonReq
         * @static
         * @param {protoCmd.IwanderPetAbandonReq} message wanderPetAbandonReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        wanderPetAbandonReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified wanderPetAbandonReq message, length delimited. Does not implicitly {@link protoCmd.wanderPetAbandonReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.wanderPetAbandonReq
         * @static
         * @param {protoCmd.IwanderPetAbandonReq} message wanderPetAbandonReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        wanderPetAbandonReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a wanderPetAbandonReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.wanderPetAbandonReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.wanderPetAbandonReq} wanderPetAbandonReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        wanderPetAbandonReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.wanderPetAbandonReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a wanderPetAbandonReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.wanderPetAbandonReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.wanderPetAbandonReq} wanderPetAbandonReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        wanderPetAbandonReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a wanderPetAbandonReq message.
         * @function verify
         * @memberof protoCmd.wanderPetAbandonReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        wanderPetAbandonReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates a wanderPetAbandonReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.wanderPetAbandonReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.wanderPetAbandonReq} wanderPetAbandonReq
         */
        wanderPetAbandonReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.wanderPetAbandonReq)
                return object;
            return new $root.protoCmd.wanderPetAbandonReq();
        };

        /**
         * Creates a plain object from a wanderPetAbandonReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.wanderPetAbandonReq
         * @static
         * @param {protoCmd.wanderPetAbandonReq} message wanderPetAbandonReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        wanderPetAbandonReq.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this wanderPetAbandonReq to JSON.
         * @function toJSON
         * @memberof protoCmd.wanderPetAbandonReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        wanderPetAbandonReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return wanderPetAbandonReq;
    })();

    protoCmd.wanderPetAdoptReq = (function() {

        /**
         * Properties of a wanderPetAdoptReq.
         * @memberof protoCmd
         * @interface IwanderPetAdoptReq
         */

        /**
         * Constructs a new wanderPetAdoptReq.
         * @memberof protoCmd
         * @classdesc Represents a wanderPetAdoptReq.
         * @implements IwanderPetAdoptReq
         * @constructor
         * @param {protoCmd.IwanderPetAdoptReq=} [properties] Properties to set
         */
        function wanderPetAdoptReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new wanderPetAdoptReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.wanderPetAdoptReq
         * @static
         * @param {protoCmd.IwanderPetAdoptReq=} [properties] Properties to set
         * @returns {protoCmd.wanderPetAdoptReq} wanderPetAdoptReq instance
         */
        wanderPetAdoptReq.create = function create(properties) {
            return new wanderPetAdoptReq(properties);
        };

        /**
         * Encodes the specified wanderPetAdoptReq message. Does not implicitly {@link protoCmd.wanderPetAdoptReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.wanderPetAdoptReq
         * @static
         * @param {protoCmd.IwanderPetAdoptReq} message wanderPetAdoptReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        wanderPetAdoptReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified wanderPetAdoptReq message, length delimited. Does not implicitly {@link protoCmd.wanderPetAdoptReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.wanderPetAdoptReq
         * @static
         * @param {protoCmd.IwanderPetAdoptReq} message wanderPetAdoptReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        wanderPetAdoptReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a wanderPetAdoptReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.wanderPetAdoptReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.wanderPetAdoptReq} wanderPetAdoptReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        wanderPetAdoptReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.wanderPetAdoptReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a wanderPetAdoptReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.wanderPetAdoptReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.wanderPetAdoptReq} wanderPetAdoptReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        wanderPetAdoptReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a wanderPetAdoptReq message.
         * @function verify
         * @memberof protoCmd.wanderPetAdoptReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        wanderPetAdoptReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates a wanderPetAdoptReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.wanderPetAdoptReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.wanderPetAdoptReq} wanderPetAdoptReq
         */
        wanderPetAdoptReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.wanderPetAdoptReq)
                return object;
            return new $root.protoCmd.wanderPetAdoptReq();
        };

        /**
         * Creates a plain object from a wanderPetAdoptReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.wanderPetAdoptReq
         * @static
         * @param {protoCmd.wanderPetAdoptReq} message wanderPetAdoptReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        wanderPetAdoptReq.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this wanderPetAdoptReq to JSON.
         * @function toJSON
         * @memberof protoCmd.wanderPetAdoptReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        wanderPetAdoptReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return wanderPetAdoptReq;
    })();

    protoCmd.petExpReq = (function() {

        /**
         * Properties of a petExpReq.
         * @memberof protoCmd
         * @interface IpetExpReq
         */

        /**
         * Constructs a new petExpReq.
         * @memberof protoCmd
         * @classdesc Represents a petExpReq.
         * @implements IpetExpReq
         * @constructor
         * @param {protoCmd.IpetExpReq=} [properties] Properties to set
         */
        function petExpReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new petExpReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.petExpReq
         * @static
         * @param {protoCmd.IpetExpReq=} [properties] Properties to set
         * @returns {protoCmd.petExpReq} petExpReq instance
         */
        petExpReq.create = function create(properties) {
            return new petExpReq(properties);
        };

        /**
         * Encodes the specified petExpReq message. Does not implicitly {@link protoCmd.petExpReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.petExpReq
         * @static
         * @param {protoCmd.IpetExpReq} message petExpReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        petExpReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified petExpReq message, length delimited. Does not implicitly {@link protoCmd.petExpReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.petExpReq
         * @static
         * @param {protoCmd.IpetExpReq} message petExpReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        petExpReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a petExpReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.petExpReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.petExpReq} petExpReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        petExpReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.petExpReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a petExpReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.petExpReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.petExpReq} petExpReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        petExpReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a petExpReq message.
         * @function verify
         * @memberof protoCmd.petExpReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        petExpReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates a petExpReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.petExpReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.petExpReq} petExpReq
         */
        petExpReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.petExpReq)
                return object;
            return new $root.protoCmd.petExpReq();
        };

        /**
         * Creates a plain object from a petExpReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.petExpReq
         * @static
         * @param {protoCmd.petExpReq} message petExpReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        petExpReq.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this petExpReq to JSON.
         * @function toJSON
         * @memberof protoCmd.petExpReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        petExpReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return petExpReq;
    })();

    protoCmd.petExpRes = (function() {

        /**
         * Properties of a petExpRes.
         * @memberof protoCmd
         * @interface IpetExpRes
         */

        /**
         * Constructs a new petExpRes.
         * @memberof protoCmd
         * @classdesc Represents a petExpRes.
         * @implements IpetExpRes
         * @constructor
         * @param {protoCmd.IpetExpRes=} [properties] Properties to set
         */
        function petExpRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new petExpRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.petExpRes
         * @static
         * @param {protoCmd.IpetExpRes=} [properties] Properties to set
         * @returns {protoCmd.petExpRes} petExpRes instance
         */
        petExpRes.create = function create(properties) {
            return new petExpRes(properties);
        };

        /**
         * Encodes the specified petExpRes message. Does not implicitly {@link protoCmd.petExpRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.petExpRes
         * @static
         * @param {protoCmd.IpetExpRes} message petExpRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        petExpRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified petExpRes message, length delimited. Does not implicitly {@link protoCmd.petExpRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.petExpRes
         * @static
         * @param {protoCmd.IpetExpRes} message petExpRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        petExpRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a petExpRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.petExpRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.petExpRes} petExpRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        petExpRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.petExpRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a petExpRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.petExpRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.petExpRes} petExpRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        petExpRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a petExpRes message.
         * @function verify
         * @memberof protoCmd.petExpRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        petExpRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates a petExpRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.petExpRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.petExpRes} petExpRes
         */
        petExpRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.petExpRes)
                return object;
            return new $root.protoCmd.petExpRes();
        };

        /**
         * Creates a plain object from a petExpRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.petExpRes
         * @static
         * @param {protoCmd.petExpRes} message petExpRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        petExpRes.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this petExpRes to JSON.
         * @function toJSON
         * @memberof protoCmd.petExpRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        petExpRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return petExpRes;
    })();

    protoCmd.attrDict = (function() {

        /**
         * Properties of an attrDict.
         * @memberof protoCmd
         * @interface IattrDict
         * @property {number|null} [id] attrDict id
         * @property {number|Long|null} [num] attrDict num
         */

        /**
         * Constructs a new attrDict.
         * @memberof protoCmd
         * @classdesc Represents an attrDict.
         * @implements IattrDict
         * @constructor
         * @param {protoCmd.IattrDict=} [properties] Properties to set
         */
        function attrDict(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * attrDict id.
         * @member {number} id
         * @memberof protoCmd.attrDict
         * @instance
         */
        attrDict.prototype.id = 0;

        /**
         * attrDict num.
         * @member {number|Long} num
         * @memberof protoCmd.attrDict
         * @instance
         */
        attrDict.prototype.num = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new attrDict instance using the specified properties.
         * @function create
         * @memberof protoCmd.attrDict
         * @static
         * @param {protoCmd.IattrDict=} [properties] Properties to set
         * @returns {protoCmd.attrDict} attrDict instance
         */
        attrDict.create = function create(properties) {
            return new attrDict(properties);
        };

        /**
         * Encodes the specified attrDict message. Does not implicitly {@link protoCmd.attrDict.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.attrDict
         * @static
         * @param {protoCmd.IattrDict} message attrDict message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        attrDict.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.id != null && Object.hasOwnProperty.call(message, "id"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.id);
            if (message.num != null && Object.hasOwnProperty.call(message, "num"))
                writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.num);
            return writer;
        };

        /**
         * Encodes the specified attrDict message, length delimited. Does not implicitly {@link protoCmd.attrDict.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.attrDict
         * @static
         * @param {protoCmd.IattrDict} message attrDict message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        attrDict.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an attrDict message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.attrDict
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.attrDict} attrDict
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        attrDict.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.attrDict();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.id = reader.uint32();
                    break;
                case 2:
                    message.num = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes an attrDict message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.attrDict
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.attrDict} attrDict
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        attrDict.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an attrDict message.
         * @function verify
         * @memberof protoCmd.attrDict
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        attrDict.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.id != null && message.hasOwnProperty("id"))
                if (!$util.isInteger(message.id))
                    return "id: integer expected";
            if (message.num != null && message.hasOwnProperty("num"))
                if (!$util.isInteger(message.num) && !(message.num && $util.isInteger(message.num.low) && $util.isInteger(message.num.high)))
                    return "num: integer|Long expected";
            return null;
        };

        /**
         * Creates an attrDict message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.attrDict
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.attrDict} attrDict
         */
        attrDict.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.attrDict)
                return object;
            var message = new $root.protoCmd.attrDict();
            if (object.id != null)
                message.id = object.id >>> 0;
            if (object.num != null)
                if ($util.Long)
                    (message.num = $util.Long.fromValue(object.num)).unsigned = true;
                else if (typeof object.num === "string")
                    message.num = parseInt(object.num, 10);
                else if (typeof object.num === "number")
                    message.num = object.num;
                else if (typeof object.num === "object")
                    message.num = new $util.LongBits(object.num.low >>> 0, object.num.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from an attrDict message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.attrDict
         * @static
         * @param {protoCmd.attrDict} message attrDict
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        attrDict.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                object.id = 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.num = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.num = options.longs === String ? "0" : 0;
            }
            if (message.id != null && message.hasOwnProperty("id"))
                object.id = message.id;
            if (message.num != null && message.hasOwnProperty("num"))
                if (typeof message.num === "number")
                    object.num = options.longs === String ? String(message.num) : message.num;
                else
                    object.num = options.longs === String ? $util.Long.prototype.toString.call(message.num) : options.longs === Number ? new $util.LongBits(message.num.low >>> 0, message.num.high >>> 0).toNumber(true) : message.num;
            return object;
        };

        /**
         * Converts this attrDict to JSON.
         * @function toJSON
         * @memberof protoCmd.attrDict
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        attrDict.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return attrDict;
    })();

    protoCmd.userInfoSyn = (function() {

        /**
         * Properties of a userInfoSyn.
         * @memberof protoCmd
         * @interface IuserInfoSyn
         * @property {number|Long|null} [actorid] userInfoSyn actorid
         * @property {string|null} [name] userInfoSyn name
         * @property {number|Long|null} [rtime] userInfoSyn rtime
         * @property {number|Long|null} [level] userInfoSyn level
         * @property {number|Long|null} [exp] userInfoSyn exp
         * @property {number|Long|null} [power] userInfoSyn power
         * @property {number|Long|null} [coin] userInfoSyn coin
         * @property {number|Long|null} [diamond] userInfoSyn diamond
         * @property {number|Long|null} [head] userInfoSyn head
         * @property {number|Long|null} [maintenanceSign] userInfoSyn maintenanceSign
         * @property {boolean|null} [sidebarReward] userInfoSyn sidebarReward
         * @property {Array.<protoCmd.IattrDict>|null} [attrList] userInfoSyn attrList
         * @property {Array.<number>|null} [headList] userInfoSyn headList
         * @property {Array.<number>|null} [toyList] userInfoSyn toyList
         */

        /**
         * Constructs a new userInfoSyn.
         * @memberof protoCmd
         * @classdesc Represents a userInfoSyn.
         * @implements IuserInfoSyn
         * @constructor
         * @param {protoCmd.IuserInfoSyn=} [properties] Properties to set
         */
        function userInfoSyn(properties) {
            this.attrList = [];
            this.headList = [];
            this.toyList = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * userInfoSyn actorid.
         * @member {number|Long} actorid
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.actorid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * userInfoSyn name.
         * @member {string} name
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.name = "";

        /**
         * userInfoSyn rtime.
         * @member {number|Long} rtime
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.rtime = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * userInfoSyn level.
         * @member {number|Long} level
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.level = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * userInfoSyn exp.
         * @member {number|Long} exp
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.exp = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * userInfoSyn power.
         * @member {number|Long} power
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.power = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * userInfoSyn coin.
         * @member {number|Long} coin
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.coin = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * userInfoSyn diamond.
         * @member {number|Long} diamond
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.diamond = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * userInfoSyn head.
         * @member {number|Long} head
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.head = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * userInfoSyn maintenanceSign.
         * @member {number|Long} maintenanceSign
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.maintenanceSign = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * userInfoSyn sidebarReward.
         * @member {boolean} sidebarReward
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.sidebarReward = false;

        /**
         * userInfoSyn attrList.
         * @member {Array.<protoCmd.IattrDict>} attrList
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.attrList = $util.emptyArray;

        /**
         * userInfoSyn headList.
         * @member {Array.<number>} headList
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.headList = $util.emptyArray;

        /**
         * userInfoSyn toyList.
         * @member {Array.<number>} toyList
         * @memberof protoCmd.userInfoSyn
         * @instance
         */
        userInfoSyn.prototype.toyList = $util.emptyArray;

        /**
         * Creates a new userInfoSyn instance using the specified properties.
         * @function create
         * @memberof protoCmd.userInfoSyn
         * @static
         * @param {protoCmd.IuserInfoSyn=} [properties] Properties to set
         * @returns {protoCmd.userInfoSyn} userInfoSyn instance
         */
        userInfoSyn.create = function create(properties) {
            return new userInfoSyn(properties);
        };

        /**
         * Encodes the specified userInfoSyn message. Does not implicitly {@link protoCmd.userInfoSyn.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.userInfoSyn
         * @static
         * @param {protoCmd.IuserInfoSyn} message userInfoSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        userInfoSyn.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.actorid != null && Object.hasOwnProperty.call(message, "actorid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.actorid);
            if (message.name != null && Object.hasOwnProperty.call(message, "name"))
                writer.uint32(/* id 2, wireType 2 =*/18).string(message.name);
            if (message.rtime != null && Object.hasOwnProperty.call(message, "rtime"))
                writer.uint32(/* id 3, wireType 0 =*/24).uint64(message.rtime);
            if (message.level != null && Object.hasOwnProperty.call(message, "level"))
                writer.uint32(/* id 4, wireType 0 =*/32).uint64(message.level);
            if (message.exp != null && Object.hasOwnProperty.call(message, "exp"))
                writer.uint32(/* id 5, wireType 0 =*/40).uint64(message.exp);
            if (message.power != null && Object.hasOwnProperty.call(message, "power"))
                writer.uint32(/* id 6, wireType 0 =*/48).uint64(message.power);
            if (message.coin != null && Object.hasOwnProperty.call(message, "coin"))
                writer.uint32(/* id 7, wireType 0 =*/56).uint64(message.coin);
            if (message.diamond != null && Object.hasOwnProperty.call(message, "diamond"))
                writer.uint32(/* id 8, wireType 0 =*/64).uint64(message.diamond);
            if (message.head != null && Object.hasOwnProperty.call(message, "head"))
                writer.uint32(/* id 9, wireType 0 =*/72).uint64(message.head);
            if (message.maintenanceSign != null && Object.hasOwnProperty.call(message, "maintenanceSign"))
                writer.uint32(/* id 10, wireType 0 =*/80).uint64(message.maintenanceSign);
            if (message.sidebarReward != null && Object.hasOwnProperty.call(message, "sidebarReward"))
                writer.uint32(/* id 11, wireType 0 =*/88).bool(message.sidebarReward);
            if (message.attrList != null && message.attrList.length)
                for (var i = 0; i < message.attrList.length; ++i)
                    $root.protoCmd.attrDict.encode(message.attrList[i], writer.uint32(/* id 12, wireType 2 =*/98).fork()).ldelim();
            if (message.headList != null && message.headList.length) {
                writer.uint32(/* id 13, wireType 2 =*/106).fork();
                for (var i = 0; i < message.headList.length; ++i)
                    writer.uint32(message.headList[i]);
                writer.ldelim();
            }
            if (message.toyList != null && message.toyList.length) {
                writer.uint32(/* id 14, wireType 2 =*/114).fork();
                for (var i = 0; i < message.toyList.length; ++i)
                    writer.uint32(message.toyList[i]);
                writer.ldelim();
            }
            return writer;
        };

        /**
         * Encodes the specified userInfoSyn message, length delimited. Does not implicitly {@link protoCmd.userInfoSyn.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.userInfoSyn
         * @static
         * @param {protoCmd.IuserInfoSyn} message userInfoSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        userInfoSyn.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a userInfoSyn message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.userInfoSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.userInfoSyn} userInfoSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        userInfoSyn.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.userInfoSyn();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.actorid = reader.uint64();
                    break;
                case 2:
                    message.name = reader.string();
                    break;
                case 3:
                    message.rtime = reader.uint64();
                    break;
                case 4:
                    message.level = reader.uint64();
                    break;
                case 5:
                    message.exp = reader.uint64();
                    break;
                case 6:
                    message.power = reader.uint64();
                    break;
                case 7:
                    message.coin = reader.uint64();
                    break;
                case 8:
                    message.diamond = reader.uint64();
                    break;
                case 9:
                    message.head = reader.uint64();
                    break;
                case 10:
                    message.maintenanceSign = reader.uint64();
                    break;
                case 11:
                    message.sidebarReward = reader.bool();
                    break;
                case 12:
                    if (!(message.attrList && message.attrList.length))
                        message.attrList = [];
                    message.attrList.push($root.protoCmd.attrDict.decode(reader, reader.uint32()));
                    break;
                case 13:
                    if (!(message.headList && message.headList.length))
                        message.headList = [];
                    if ((tag & 7) === 2) {
                        var end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2)
                            message.headList.push(reader.uint32());
                    } else
                        message.headList.push(reader.uint32());
                    break;
                case 14:
                    if (!(message.toyList && message.toyList.length))
                        message.toyList = [];
                    if ((tag & 7) === 2) {
                        var end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2)
                            message.toyList.push(reader.uint32());
                    } else
                        message.toyList.push(reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a userInfoSyn message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.userInfoSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.userInfoSyn} userInfoSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        userInfoSyn.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a userInfoSyn message.
         * @function verify
         * @memberof protoCmd.userInfoSyn
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        userInfoSyn.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.actorid != null && message.hasOwnProperty("actorid"))
                if (!$util.isInteger(message.actorid) && !(message.actorid && $util.isInteger(message.actorid.low) && $util.isInteger(message.actorid.high)))
                    return "actorid: integer|Long expected";
            if (message.name != null && message.hasOwnProperty("name"))
                if (!$util.isString(message.name))
                    return "name: string expected";
            if (message.rtime != null && message.hasOwnProperty("rtime"))
                if (!$util.isInteger(message.rtime) && !(message.rtime && $util.isInteger(message.rtime.low) && $util.isInteger(message.rtime.high)))
                    return "rtime: integer|Long expected";
            if (message.level != null && message.hasOwnProperty("level"))
                if (!$util.isInteger(message.level) && !(message.level && $util.isInteger(message.level.low) && $util.isInteger(message.level.high)))
                    return "level: integer|Long expected";
            if (message.exp != null && message.hasOwnProperty("exp"))
                if (!$util.isInteger(message.exp) && !(message.exp && $util.isInteger(message.exp.low) && $util.isInteger(message.exp.high)))
                    return "exp: integer|Long expected";
            if (message.power != null && message.hasOwnProperty("power"))
                if (!$util.isInteger(message.power) && !(message.power && $util.isInteger(message.power.low) && $util.isInteger(message.power.high)))
                    return "power: integer|Long expected";
            if (message.coin != null && message.hasOwnProperty("coin"))
                if (!$util.isInteger(message.coin) && !(message.coin && $util.isInteger(message.coin.low) && $util.isInteger(message.coin.high)))
                    return "coin: integer|Long expected";
            if (message.diamond != null && message.hasOwnProperty("diamond"))
                if (!$util.isInteger(message.diamond) && !(message.diamond && $util.isInteger(message.diamond.low) && $util.isInteger(message.diamond.high)))
                    return "diamond: integer|Long expected";
            if (message.head != null && message.hasOwnProperty("head"))
                if (!$util.isInteger(message.head) && !(message.head && $util.isInteger(message.head.low) && $util.isInteger(message.head.high)))
                    return "head: integer|Long expected";
            if (message.maintenanceSign != null && message.hasOwnProperty("maintenanceSign"))
                if (!$util.isInteger(message.maintenanceSign) && !(message.maintenanceSign && $util.isInteger(message.maintenanceSign.low) && $util.isInteger(message.maintenanceSign.high)))
                    return "maintenanceSign: integer|Long expected";
            if (message.sidebarReward != null && message.hasOwnProperty("sidebarReward"))
                if (typeof message.sidebarReward !== "boolean")
                    return "sidebarReward: boolean expected";
            if (message.attrList != null && message.hasOwnProperty("attrList")) {
                if (!Array.isArray(message.attrList))
                    return "attrList: array expected";
                for (var i = 0; i < message.attrList.length; ++i) {
                    var error = $root.protoCmd.attrDict.verify(message.attrList[i]);
                    if (error)
                        return "attrList." + error;
                }
            }
            if (message.headList != null && message.hasOwnProperty("headList")) {
                if (!Array.isArray(message.headList))
                    return "headList: array expected";
                for (var i = 0; i < message.headList.length; ++i)
                    if (!$util.isInteger(message.headList[i]))
                        return "headList: integer[] expected";
            }
            if (message.toyList != null && message.hasOwnProperty("toyList")) {
                if (!Array.isArray(message.toyList))
                    return "toyList: array expected";
                for (var i = 0; i < message.toyList.length; ++i)
                    if (!$util.isInteger(message.toyList[i]))
                        return "toyList: integer[] expected";
            }
            return null;
        };

        /**
         * Creates a userInfoSyn message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.userInfoSyn
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.userInfoSyn} userInfoSyn
         */
        userInfoSyn.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.userInfoSyn)
                return object;
            var message = new $root.protoCmd.userInfoSyn();
            if (object.actorid != null)
                if ($util.Long)
                    (message.actorid = $util.Long.fromValue(object.actorid)).unsigned = true;
                else if (typeof object.actorid === "string")
                    message.actorid = parseInt(object.actorid, 10);
                else if (typeof object.actorid === "number")
                    message.actorid = object.actorid;
                else if (typeof object.actorid === "object")
                    message.actorid = new $util.LongBits(object.actorid.low >>> 0, object.actorid.high >>> 0).toNumber(true);
            if (object.name != null)
                message.name = String(object.name);
            if (object.rtime != null)
                if ($util.Long)
                    (message.rtime = $util.Long.fromValue(object.rtime)).unsigned = true;
                else if (typeof object.rtime === "string")
                    message.rtime = parseInt(object.rtime, 10);
                else if (typeof object.rtime === "number")
                    message.rtime = object.rtime;
                else if (typeof object.rtime === "object")
                    message.rtime = new $util.LongBits(object.rtime.low >>> 0, object.rtime.high >>> 0).toNumber(true);
            if (object.level != null)
                if ($util.Long)
                    (message.level = $util.Long.fromValue(object.level)).unsigned = true;
                else if (typeof object.level === "string")
                    message.level = parseInt(object.level, 10);
                else if (typeof object.level === "number")
                    message.level = object.level;
                else if (typeof object.level === "object")
                    message.level = new $util.LongBits(object.level.low >>> 0, object.level.high >>> 0).toNumber(true);
            if (object.exp != null)
                if ($util.Long)
                    (message.exp = $util.Long.fromValue(object.exp)).unsigned = true;
                else if (typeof object.exp === "string")
                    message.exp = parseInt(object.exp, 10);
                else if (typeof object.exp === "number")
                    message.exp = object.exp;
                else if (typeof object.exp === "object")
                    message.exp = new $util.LongBits(object.exp.low >>> 0, object.exp.high >>> 0).toNumber(true);
            if (object.power != null)
                if ($util.Long)
                    (message.power = $util.Long.fromValue(object.power)).unsigned = true;
                else if (typeof object.power === "string")
                    message.power = parseInt(object.power, 10);
                else if (typeof object.power === "number")
                    message.power = object.power;
                else if (typeof object.power === "object")
                    message.power = new $util.LongBits(object.power.low >>> 0, object.power.high >>> 0).toNumber(true);
            if (object.coin != null)
                if ($util.Long)
                    (message.coin = $util.Long.fromValue(object.coin)).unsigned = true;
                else if (typeof object.coin === "string")
                    message.coin = parseInt(object.coin, 10);
                else if (typeof object.coin === "number")
                    message.coin = object.coin;
                else if (typeof object.coin === "object")
                    message.coin = new $util.LongBits(object.coin.low >>> 0, object.coin.high >>> 0).toNumber(true);
            if (object.diamond != null)
                if ($util.Long)
                    (message.diamond = $util.Long.fromValue(object.diamond)).unsigned = true;
                else if (typeof object.diamond === "string")
                    message.diamond = parseInt(object.diamond, 10);
                else if (typeof object.diamond === "number")
                    message.diamond = object.diamond;
                else if (typeof object.diamond === "object")
                    message.diamond = new $util.LongBits(object.diamond.low >>> 0, object.diamond.high >>> 0).toNumber(true);
            if (object.head != null)
                if ($util.Long)
                    (message.head = $util.Long.fromValue(object.head)).unsigned = true;
                else if (typeof object.head === "string")
                    message.head = parseInt(object.head, 10);
                else if (typeof object.head === "number")
                    message.head = object.head;
                else if (typeof object.head === "object")
                    message.head = new $util.LongBits(object.head.low >>> 0, object.head.high >>> 0).toNumber(true);
            if (object.maintenanceSign != null)
                if ($util.Long)
                    (message.maintenanceSign = $util.Long.fromValue(object.maintenanceSign)).unsigned = true;
                else if (typeof object.maintenanceSign === "string")
                    message.maintenanceSign = parseInt(object.maintenanceSign, 10);
                else if (typeof object.maintenanceSign === "number")
                    message.maintenanceSign = object.maintenanceSign;
                else if (typeof object.maintenanceSign === "object")
                    message.maintenanceSign = new $util.LongBits(object.maintenanceSign.low >>> 0, object.maintenanceSign.high >>> 0).toNumber(true);
            if (object.sidebarReward != null)
                message.sidebarReward = Boolean(object.sidebarReward);
            if (object.attrList) {
                if (!Array.isArray(object.attrList))
                    throw TypeError(".protoCmd.userInfoSyn.attrList: array expected");
                message.attrList = [];
                for (var i = 0; i < object.attrList.length; ++i) {
                    if (typeof object.attrList[i] !== "object")
                        throw TypeError(".protoCmd.userInfoSyn.attrList: object expected");
                    message.attrList[i] = $root.protoCmd.attrDict.fromObject(object.attrList[i]);
                }
            }
            if (object.headList) {
                if (!Array.isArray(object.headList))
                    throw TypeError(".protoCmd.userInfoSyn.headList: array expected");
                message.headList = [];
                for (var i = 0; i < object.headList.length; ++i)
                    message.headList[i] = object.headList[i] >>> 0;
            }
            if (object.toyList) {
                if (!Array.isArray(object.toyList))
                    throw TypeError(".protoCmd.userInfoSyn.toyList: array expected");
                message.toyList = [];
                for (var i = 0; i < object.toyList.length; ++i)
                    message.toyList[i] = object.toyList[i] >>> 0;
            }
            return message;
        };

        /**
         * Creates a plain object from a userInfoSyn message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.userInfoSyn
         * @static
         * @param {protoCmd.userInfoSyn} message userInfoSyn
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        userInfoSyn.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.arrays || options.defaults) {
                object.attrList = [];
                object.headList = [];
                object.toyList = [];
            }
            if (options.defaults) {
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.actorid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.actorid = options.longs === String ? "0" : 0;
                object.name = "";
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.rtime = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.rtime = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.level = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.level = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.exp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.exp = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.power = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.power = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.coin = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.coin = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.diamond = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.diamond = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.head = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.head = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.maintenanceSign = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.maintenanceSign = options.longs === String ? "0" : 0;
                object.sidebarReward = false;
            }
            if (message.actorid != null && message.hasOwnProperty("actorid"))
                if (typeof message.actorid === "number")
                    object.actorid = options.longs === String ? String(message.actorid) : message.actorid;
                else
                    object.actorid = options.longs === String ? $util.Long.prototype.toString.call(message.actorid) : options.longs === Number ? new $util.LongBits(message.actorid.low >>> 0, message.actorid.high >>> 0).toNumber(true) : message.actorid;
            if (message.name != null && message.hasOwnProperty("name"))
                object.name = message.name;
            if (message.rtime != null && message.hasOwnProperty("rtime"))
                if (typeof message.rtime === "number")
                    object.rtime = options.longs === String ? String(message.rtime) : message.rtime;
                else
                    object.rtime = options.longs === String ? $util.Long.prototype.toString.call(message.rtime) : options.longs === Number ? new $util.LongBits(message.rtime.low >>> 0, message.rtime.high >>> 0).toNumber(true) : message.rtime;
            if (message.level != null && message.hasOwnProperty("level"))
                if (typeof message.level === "number")
                    object.level = options.longs === String ? String(message.level) : message.level;
                else
                    object.level = options.longs === String ? $util.Long.prototype.toString.call(message.level) : options.longs === Number ? new $util.LongBits(message.level.low >>> 0, message.level.high >>> 0).toNumber(true) : message.level;
            if (message.exp != null && message.hasOwnProperty("exp"))
                if (typeof message.exp === "number")
                    object.exp = options.longs === String ? String(message.exp) : message.exp;
                else
                    object.exp = options.longs === String ? $util.Long.prototype.toString.call(message.exp) : options.longs === Number ? new $util.LongBits(message.exp.low >>> 0, message.exp.high >>> 0).toNumber(true) : message.exp;
            if (message.power != null && message.hasOwnProperty("power"))
                if (typeof message.power === "number")
                    object.power = options.longs === String ? String(message.power) : message.power;
                else
                    object.power = options.longs === String ? $util.Long.prototype.toString.call(message.power) : options.longs === Number ? new $util.LongBits(message.power.low >>> 0, message.power.high >>> 0).toNumber(true) : message.power;
            if (message.coin != null && message.hasOwnProperty("coin"))
                if (typeof message.coin === "number")
                    object.coin = options.longs === String ? String(message.coin) : message.coin;
                else
                    object.coin = options.longs === String ? $util.Long.prototype.toString.call(message.coin) : options.longs === Number ? new $util.LongBits(message.coin.low >>> 0, message.coin.high >>> 0).toNumber(true) : message.coin;
            if (message.diamond != null && message.hasOwnProperty("diamond"))
                if (typeof message.diamond === "number")
                    object.diamond = options.longs === String ? String(message.diamond) : message.diamond;
                else
                    object.diamond = options.longs === String ? $util.Long.prototype.toString.call(message.diamond) : options.longs === Number ? new $util.LongBits(message.diamond.low >>> 0, message.diamond.high >>> 0).toNumber(true) : message.diamond;
            if (message.head != null && message.hasOwnProperty("head"))
                if (typeof message.head === "number")
                    object.head = options.longs === String ? String(message.head) : message.head;
                else
                    object.head = options.longs === String ? $util.Long.prototype.toString.call(message.head) : options.longs === Number ? new $util.LongBits(message.head.low >>> 0, message.head.high >>> 0).toNumber(true) : message.head;
            if (message.maintenanceSign != null && message.hasOwnProperty("maintenanceSign"))
                if (typeof message.maintenanceSign === "number")
                    object.maintenanceSign = options.longs === String ? String(message.maintenanceSign) : message.maintenanceSign;
                else
                    object.maintenanceSign = options.longs === String ? $util.Long.prototype.toString.call(message.maintenanceSign) : options.longs === Number ? new $util.LongBits(message.maintenanceSign.low >>> 0, message.maintenanceSign.high >>> 0).toNumber(true) : message.maintenanceSign;
            if (message.sidebarReward != null && message.hasOwnProperty("sidebarReward"))
                object.sidebarReward = message.sidebarReward;
            if (message.attrList && message.attrList.length) {
                object.attrList = [];
                for (var j = 0; j < message.attrList.length; ++j)
                    object.attrList[j] = $root.protoCmd.attrDict.toObject(message.attrList[j], options);
            }
            if (message.headList && message.headList.length) {
                object.headList = [];
                for (var j = 0; j < message.headList.length; ++j)
                    object.headList[j] = message.headList[j];
            }
            if (message.toyList && message.toyList.length) {
                object.toyList = [];
                for (var j = 0; j < message.toyList.length; ++j)
                    object.toyList[j] = message.toyList[j];
            }
            return object;
        };

        /**
         * Converts this userInfoSyn to JSON.
         * @function toJSON
         * @memberof protoCmd.userInfoSyn
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        userInfoSyn.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return userInfoSyn;
    })();

    protoCmd.changeHeadReq = (function() {

        /**
         * Properties of a changeHeadReq.
         * @memberof protoCmd
         * @interface IchangeHeadReq
         * @property {number|Long|null} [cid] changeHeadReq cid
         */

        /**
         * Constructs a new changeHeadReq.
         * @memberof protoCmd
         * @classdesc Represents a changeHeadReq.
         * @implements IchangeHeadReq
         * @constructor
         * @param {protoCmd.IchangeHeadReq=} [properties] Properties to set
         */
        function changeHeadReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * changeHeadReq cid.
         * @member {number|Long} cid
         * @memberof protoCmd.changeHeadReq
         * @instance
         */
        changeHeadReq.prototype.cid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new changeHeadReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.changeHeadReq
         * @static
         * @param {protoCmd.IchangeHeadReq=} [properties] Properties to set
         * @returns {protoCmd.changeHeadReq} changeHeadReq instance
         */
        changeHeadReq.create = function create(properties) {
            return new changeHeadReq(properties);
        };

        /**
         * Encodes the specified changeHeadReq message. Does not implicitly {@link protoCmd.changeHeadReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.changeHeadReq
         * @static
         * @param {protoCmd.IchangeHeadReq} message changeHeadReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        changeHeadReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.cid != null && Object.hasOwnProperty.call(message, "cid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.cid);
            return writer;
        };

        /**
         * Encodes the specified changeHeadReq message, length delimited. Does not implicitly {@link protoCmd.changeHeadReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.changeHeadReq
         * @static
         * @param {protoCmd.IchangeHeadReq} message changeHeadReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        changeHeadReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a changeHeadReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.changeHeadReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.changeHeadReq} changeHeadReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        changeHeadReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.changeHeadReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.cid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a changeHeadReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.changeHeadReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.changeHeadReq} changeHeadReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        changeHeadReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a changeHeadReq message.
         * @function verify
         * @memberof protoCmd.changeHeadReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        changeHeadReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (!$util.isInteger(message.cid) && !(message.cid && $util.isInteger(message.cid.low) && $util.isInteger(message.cid.high)))
                    return "cid: integer|Long expected";
            return null;
        };

        /**
         * Creates a changeHeadReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.changeHeadReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.changeHeadReq} changeHeadReq
         */
        changeHeadReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.changeHeadReq)
                return object;
            var message = new $root.protoCmd.changeHeadReq();
            if (object.cid != null)
                if ($util.Long)
                    (message.cid = $util.Long.fromValue(object.cid)).unsigned = true;
                else if (typeof object.cid === "string")
                    message.cid = parseInt(object.cid, 10);
                else if (typeof object.cid === "number")
                    message.cid = object.cid;
                else if (typeof object.cid === "object")
                    message.cid = new $util.LongBits(object.cid.low >>> 0, object.cid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a changeHeadReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.changeHeadReq
         * @static
         * @param {protoCmd.changeHeadReq} message changeHeadReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        changeHeadReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.cid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.cid = options.longs === String ? "0" : 0;
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (typeof message.cid === "number")
                    object.cid = options.longs === String ? String(message.cid) : message.cid;
                else
                    object.cid = options.longs === String ? $util.Long.prototype.toString.call(message.cid) : options.longs === Number ? new $util.LongBits(message.cid.low >>> 0, message.cid.high >>> 0).toNumber(true) : message.cid;
            return object;
        };

        /**
         * Converts this changeHeadReq to JSON.
         * @function toJSON
         * @memberof protoCmd.changeHeadReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        changeHeadReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return changeHeadReq;
    })();

    protoCmd.changeHeadRes = (function() {

        /**
         * Properties of a changeHeadRes.
         * @memberof protoCmd
         * @interface IchangeHeadRes
         * @property {number|Long|null} [cid] changeHeadRes cid
         */

        /**
         * Constructs a new changeHeadRes.
         * @memberof protoCmd
         * @classdesc Represents a changeHeadRes.
         * @implements IchangeHeadRes
         * @constructor
         * @param {protoCmd.IchangeHeadRes=} [properties] Properties to set
         */
        function changeHeadRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * changeHeadRes cid.
         * @member {number|Long} cid
         * @memberof protoCmd.changeHeadRes
         * @instance
         */
        changeHeadRes.prototype.cid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new changeHeadRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.changeHeadRes
         * @static
         * @param {protoCmd.IchangeHeadRes=} [properties] Properties to set
         * @returns {protoCmd.changeHeadRes} changeHeadRes instance
         */
        changeHeadRes.create = function create(properties) {
            return new changeHeadRes(properties);
        };

        /**
         * Encodes the specified changeHeadRes message. Does not implicitly {@link protoCmd.changeHeadRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.changeHeadRes
         * @static
         * @param {protoCmd.IchangeHeadRes} message changeHeadRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        changeHeadRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.cid != null && Object.hasOwnProperty.call(message, "cid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.cid);
            return writer;
        };

        /**
         * Encodes the specified changeHeadRes message, length delimited. Does not implicitly {@link protoCmd.changeHeadRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.changeHeadRes
         * @static
         * @param {protoCmd.IchangeHeadRes} message changeHeadRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        changeHeadRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a changeHeadRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.changeHeadRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.changeHeadRes} changeHeadRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        changeHeadRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.changeHeadRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.cid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a changeHeadRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.changeHeadRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.changeHeadRes} changeHeadRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        changeHeadRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a changeHeadRes message.
         * @function verify
         * @memberof protoCmd.changeHeadRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        changeHeadRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (!$util.isInteger(message.cid) && !(message.cid && $util.isInteger(message.cid.low) && $util.isInteger(message.cid.high)))
                    return "cid: integer|Long expected";
            return null;
        };

        /**
         * Creates a changeHeadRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.changeHeadRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.changeHeadRes} changeHeadRes
         */
        changeHeadRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.changeHeadRes)
                return object;
            var message = new $root.protoCmd.changeHeadRes();
            if (object.cid != null)
                if ($util.Long)
                    (message.cid = $util.Long.fromValue(object.cid)).unsigned = true;
                else if (typeof object.cid === "string")
                    message.cid = parseInt(object.cid, 10);
                else if (typeof object.cid === "number")
                    message.cid = object.cid;
                else if (typeof object.cid === "object")
                    message.cid = new $util.LongBits(object.cid.low >>> 0, object.cid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a changeHeadRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.changeHeadRes
         * @static
         * @param {protoCmd.changeHeadRes} message changeHeadRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        changeHeadRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.cid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.cid = options.longs === String ? "0" : 0;
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (typeof message.cid === "number")
                    object.cid = options.longs === String ? String(message.cid) : message.cid;
                else
                    object.cid = options.longs === String ? $util.Long.prototype.toString.call(message.cid) : options.longs === Number ? new $util.LongBits(message.cid.low >>> 0, message.cid.high >>> 0).toNumber(true) : message.cid;
            return object;
        };

        /**
         * Converts this changeHeadRes to JSON.
         * @function toJSON
         * @memberof protoCmd.changeHeadRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        changeHeadRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return changeHeadRes;
    })();

    protoCmd.changeUserNameReq = (function() {

        /**
         * Properties of a changeUserNameReq.
         * @memberof protoCmd
         * @interface IchangeUserNameReq
         * @property {string|null} [name] changeUserNameReq name
         */

        /**
         * Constructs a new changeUserNameReq.
         * @memberof protoCmd
         * @classdesc Represents a changeUserNameReq.
         * @implements IchangeUserNameReq
         * @constructor
         * @param {protoCmd.IchangeUserNameReq=} [properties] Properties to set
         */
        function changeUserNameReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * changeUserNameReq name.
         * @member {string} name
         * @memberof protoCmd.changeUserNameReq
         * @instance
         */
        changeUserNameReq.prototype.name = "";

        /**
         * Creates a new changeUserNameReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.changeUserNameReq
         * @static
         * @param {protoCmd.IchangeUserNameReq=} [properties] Properties to set
         * @returns {protoCmd.changeUserNameReq} changeUserNameReq instance
         */
        changeUserNameReq.create = function create(properties) {
            return new changeUserNameReq(properties);
        };

        /**
         * Encodes the specified changeUserNameReq message. Does not implicitly {@link protoCmd.changeUserNameReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.changeUserNameReq
         * @static
         * @param {protoCmd.IchangeUserNameReq} message changeUserNameReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        changeUserNameReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.name != null && Object.hasOwnProperty.call(message, "name"))
                writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
            return writer;
        };

        /**
         * Encodes the specified changeUserNameReq message, length delimited. Does not implicitly {@link protoCmd.changeUserNameReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.changeUserNameReq
         * @static
         * @param {protoCmd.IchangeUserNameReq} message changeUserNameReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        changeUserNameReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a changeUserNameReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.changeUserNameReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.changeUserNameReq} changeUserNameReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        changeUserNameReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.changeUserNameReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.name = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a changeUserNameReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.changeUserNameReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.changeUserNameReq} changeUserNameReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        changeUserNameReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a changeUserNameReq message.
         * @function verify
         * @memberof protoCmd.changeUserNameReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        changeUserNameReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.name != null && message.hasOwnProperty("name"))
                if (!$util.isString(message.name))
                    return "name: string expected";
            return null;
        };

        /**
         * Creates a changeUserNameReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.changeUserNameReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.changeUserNameReq} changeUserNameReq
         */
        changeUserNameReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.changeUserNameReq)
                return object;
            var message = new $root.protoCmd.changeUserNameReq();
            if (object.name != null)
                message.name = String(object.name);
            return message;
        };

        /**
         * Creates a plain object from a changeUserNameReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.changeUserNameReq
         * @static
         * @param {protoCmd.changeUserNameReq} message changeUserNameReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        changeUserNameReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                object.name = "";
            if (message.name != null && message.hasOwnProperty("name"))
                object.name = message.name;
            return object;
        };

        /**
         * Converts this changeUserNameReq to JSON.
         * @function toJSON
         * @memberof protoCmd.changeUserNameReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        changeUserNameReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return changeUserNameReq;
    })();

    protoCmd.changeUserNameRes = (function() {

        /**
         * Properties of a changeUserNameRes.
         * @memberof protoCmd
         * @interface IchangeUserNameRes
         * @property {string|null} [name] changeUserNameRes name
         */

        /**
         * Constructs a new changeUserNameRes.
         * @memberof protoCmd
         * @classdesc Represents a changeUserNameRes.
         * @implements IchangeUserNameRes
         * @constructor
         * @param {protoCmd.IchangeUserNameRes=} [properties] Properties to set
         */
        function changeUserNameRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * changeUserNameRes name.
         * @member {string} name
         * @memberof protoCmd.changeUserNameRes
         * @instance
         */
        changeUserNameRes.prototype.name = "";

        /**
         * Creates a new changeUserNameRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.changeUserNameRes
         * @static
         * @param {protoCmd.IchangeUserNameRes=} [properties] Properties to set
         * @returns {protoCmd.changeUserNameRes} changeUserNameRes instance
         */
        changeUserNameRes.create = function create(properties) {
            return new changeUserNameRes(properties);
        };

        /**
         * Encodes the specified changeUserNameRes message. Does not implicitly {@link protoCmd.changeUserNameRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.changeUserNameRes
         * @static
         * @param {protoCmd.IchangeUserNameRes} message changeUserNameRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        changeUserNameRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.name != null && Object.hasOwnProperty.call(message, "name"))
                writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
            return writer;
        };

        /**
         * Encodes the specified changeUserNameRes message, length delimited. Does not implicitly {@link protoCmd.changeUserNameRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.changeUserNameRes
         * @static
         * @param {protoCmd.IchangeUserNameRes} message changeUserNameRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        changeUserNameRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a changeUserNameRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.changeUserNameRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.changeUserNameRes} changeUserNameRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        changeUserNameRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.changeUserNameRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.name = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a changeUserNameRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.changeUserNameRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.changeUserNameRes} changeUserNameRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        changeUserNameRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a changeUserNameRes message.
         * @function verify
         * @memberof protoCmd.changeUserNameRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        changeUserNameRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.name != null && message.hasOwnProperty("name"))
                if (!$util.isString(message.name))
                    return "name: string expected";
            return null;
        };

        /**
         * Creates a changeUserNameRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.changeUserNameRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.changeUserNameRes} changeUserNameRes
         */
        changeUserNameRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.changeUserNameRes)
                return object;
            var message = new $root.protoCmd.changeUserNameRes();
            if (object.name != null)
                message.name = String(object.name);
            return message;
        };

        /**
         * Creates a plain object from a changeUserNameRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.changeUserNameRes
         * @static
         * @param {protoCmd.changeUserNameRes} message changeUserNameRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        changeUserNameRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                object.name = "";
            if (message.name != null && message.hasOwnProperty("name"))
                object.name = message.name;
            return object;
        };

        /**
         * Converts this changeUserNameRes to JSON.
         * @function toJSON
         * @memberof protoCmd.changeUserNameRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        changeUserNameRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return changeUserNameRes;
    })();

    protoCmd.maintenanceReq = (function() {

        /**
         * Properties of a maintenanceReq.
         * @memberof protoCmd
         * @interface ImaintenanceReq
         */

        /**
         * Constructs a new maintenanceReq.
         * @memberof protoCmd
         * @classdesc Represents a maintenanceReq.
         * @implements ImaintenanceReq
         * @constructor
         * @param {protoCmd.ImaintenanceReq=} [properties] Properties to set
         */
        function maintenanceReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new maintenanceReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.maintenanceReq
         * @static
         * @param {protoCmd.ImaintenanceReq=} [properties] Properties to set
         * @returns {protoCmd.maintenanceReq} maintenanceReq instance
         */
        maintenanceReq.create = function create(properties) {
            return new maintenanceReq(properties);
        };

        /**
         * Encodes the specified maintenanceReq message. Does not implicitly {@link protoCmd.maintenanceReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.maintenanceReq
         * @static
         * @param {protoCmd.ImaintenanceReq} message maintenanceReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        maintenanceReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified maintenanceReq message, length delimited. Does not implicitly {@link protoCmd.maintenanceReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.maintenanceReq
         * @static
         * @param {protoCmd.ImaintenanceReq} message maintenanceReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        maintenanceReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a maintenanceReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.maintenanceReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.maintenanceReq} maintenanceReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        maintenanceReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.maintenanceReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a maintenanceReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.maintenanceReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.maintenanceReq} maintenanceReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        maintenanceReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a maintenanceReq message.
         * @function verify
         * @memberof protoCmd.maintenanceReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        maintenanceReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates a maintenanceReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.maintenanceReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.maintenanceReq} maintenanceReq
         */
        maintenanceReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.maintenanceReq)
                return object;
            return new $root.protoCmd.maintenanceReq();
        };

        /**
         * Creates a plain object from a maintenanceReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.maintenanceReq
         * @static
         * @param {protoCmd.maintenanceReq} message maintenanceReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        maintenanceReq.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this maintenanceReq to JSON.
         * @function toJSON
         * @memberof protoCmd.maintenanceReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        maintenanceReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return maintenanceReq;
    })();

    protoCmd.maintenanceRes = (function() {

        /**
         * Properties of a maintenanceRes.
         * @memberof protoCmd
         * @interface ImaintenanceRes
         * @property {number|Long|null} [maintenanceSign] maintenanceRes maintenanceSign
         */

        /**
         * Constructs a new maintenanceRes.
         * @memberof protoCmd
         * @classdesc Represents a maintenanceRes.
         * @implements ImaintenanceRes
         * @constructor
         * @param {protoCmd.ImaintenanceRes=} [properties] Properties to set
         */
        function maintenanceRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * maintenanceRes maintenanceSign.
         * @member {number|Long} maintenanceSign
         * @memberof protoCmd.maintenanceRes
         * @instance
         */
        maintenanceRes.prototype.maintenanceSign = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new maintenanceRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.maintenanceRes
         * @static
         * @param {protoCmd.ImaintenanceRes=} [properties] Properties to set
         * @returns {protoCmd.maintenanceRes} maintenanceRes instance
         */
        maintenanceRes.create = function create(properties) {
            return new maintenanceRes(properties);
        };

        /**
         * Encodes the specified maintenanceRes message. Does not implicitly {@link protoCmd.maintenanceRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.maintenanceRes
         * @static
         * @param {protoCmd.ImaintenanceRes} message maintenanceRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        maintenanceRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.maintenanceSign != null && Object.hasOwnProperty.call(message, "maintenanceSign"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.maintenanceSign);
            return writer;
        };

        /**
         * Encodes the specified maintenanceRes message, length delimited. Does not implicitly {@link protoCmd.maintenanceRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.maintenanceRes
         * @static
         * @param {protoCmd.ImaintenanceRes} message maintenanceRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        maintenanceRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a maintenanceRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.maintenanceRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.maintenanceRes} maintenanceRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        maintenanceRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.maintenanceRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.maintenanceSign = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a maintenanceRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.maintenanceRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.maintenanceRes} maintenanceRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        maintenanceRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a maintenanceRes message.
         * @function verify
         * @memberof protoCmd.maintenanceRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        maintenanceRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.maintenanceSign != null && message.hasOwnProperty("maintenanceSign"))
                if (!$util.isInteger(message.maintenanceSign) && !(message.maintenanceSign && $util.isInteger(message.maintenanceSign.low) && $util.isInteger(message.maintenanceSign.high)))
                    return "maintenanceSign: integer|Long expected";
            return null;
        };

        /**
         * Creates a maintenanceRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.maintenanceRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.maintenanceRes} maintenanceRes
         */
        maintenanceRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.maintenanceRes)
                return object;
            var message = new $root.protoCmd.maintenanceRes();
            if (object.maintenanceSign != null)
                if ($util.Long)
                    (message.maintenanceSign = $util.Long.fromValue(object.maintenanceSign)).unsigned = true;
                else if (typeof object.maintenanceSign === "string")
                    message.maintenanceSign = parseInt(object.maintenanceSign, 10);
                else if (typeof object.maintenanceSign === "number")
                    message.maintenanceSign = object.maintenanceSign;
                else if (typeof object.maintenanceSign === "object")
                    message.maintenanceSign = new $util.LongBits(object.maintenanceSign.low >>> 0, object.maintenanceSign.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a maintenanceRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.maintenanceRes
         * @static
         * @param {protoCmd.maintenanceRes} message maintenanceRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        maintenanceRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.maintenanceSign = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.maintenanceSign = options.longs === String ? "0" : 0;
            if (message.maintenanceSign != null && message.hasOwnProperty("maintenanceSign"))
                if (typeof message.maintenanceSign === "number")
                    object.maintenanceSign = options.longs === String ? String(message.maintenanceSign) : message.maintenanceSign;
                else
                    object.maintenanceSign = options.longs === String ? $util.Long.prototype.toString.call(message.maintenanceSign) : options.longs === Number ? new $util.LongBits(message.maintenanceSign.low >>> 0, message.maintenanceSign.high >>> 0).toNumber(true) : message.maintenanceSign;
            return object;
        };

        /**
         * Converts this maintenanceRes to JSON.
         * @function toJSON
         * @memberof protoCmd.maintenanceRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        maintenanceRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return maintenanceRes;
    })();

    protoCmd.addPetFoodReq = (function() {

        /**
         * Properties of an addPetFoodReq.
         * @memberof protoCmd
         * @interface IaddPetFoodReq
         * @property {boolean|null} [ad] addPetFoodReq ad
         */

        /**
         * Constructs a new addPetFoodReq.
         * @memberof protoCmd
         * @classdesc Represents an addPetFoodReq.
         * @implements IaddPetFoodReq
         * @constructor
         * @param {protoCmd.IaddPetFoodReq=} [properties] Properties to set
         */
        function addPetFoodReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * addPetFoodReq ad.
         * @member {boolean} ad
         * @memberof protoCmd.addPetFoodReq
         * @instance
         */
        addPetFoodReq.prototype.ad = false;

        /**
         * Creates a new addPetFoodReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.addPetFoodReq
         * @static
         * @param {protoCmd.IaddPetFoodReq=} [properties] Properties to set
         * @returns {protoCmd.addPetFoodReq} addPetFoodReq instance
         */
        addPetFoodReq.create = function create(properties) {
            return new addPetFoodReq(properties);
        };

        /**
         * Encodes the specified addPetFoodReq message. Does not implicitly {@link protoCmd.addPetFoodReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.addPetFoodReq
         * @static
         * @param {protoCmd.IaddPetFoodReq} message addPetFoodReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        addPetFoodReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.ad != null && Object.hasOwnProperty.call(message, "ad"))
                writer.uint32(/* id 1, wireType 0 =*/8).bool(message.ad);
            return writer;
        };

        /**
         * Encodes the specified addPetFoodReq message, length delimited. Does not implicitly {@link protoCmd.addPetFoodReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.addPetFoodReq
         * @static
         * @param {protoCmd.IaddPetFoodReq} message addPetFoodReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        addPetFoodReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an addPetFoodReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.addPetFoodReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.addPetFoodReq} addPetFoodReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        addPetFoodReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.addPetFoodReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.ad = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes an addPetFoodReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.addPetFoodReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.addPetFoodReq} addPetFoodReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        addPetFoodReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an addPetFoodReq message.
         * @function verify
         * @memberof protoCmd.addPetFoodReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        addPetFoodReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.ad != null && message.hasOwnProperty("ad"))
                if (typeof message.ad !== "boolean")
                    return "ad: boolean expected";
            return null;
        };

        /**
         * Creates an addPetFoodReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.addPetFoodReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.addPetFoodReq} addPetFoodReq
         */
        addPetFoodReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.addPetFoodReq)
                return object;
            var message = new $root.protoCmd.addPetFoodReq();
            if (object.ad != null)
                message.ad = Boolean(object.ad);
            return message;
        };

        /**
         * Creates a plain object from an addPetFoodReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.addPetFoodReq
         * @static
         * @param {protoCmd.addPetFoodReq} message addPetFoodReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        addPetFoodReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                object.ad = false;
            if (message.ad != null && message.hasOwnProperty("ad"))
                object.ad = message.ad;
            return object;
        };

        /**
         * Converts this addPetFoodReq to JSON.
         * @function toJSON
         * @memberof protoCmd.addPetFoodReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        addPetFoodReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return addPetFoodReq;
    })();

    protoCmd.addPetWaterReq = (function() {

        /**
         * Properties of an addPetWaterReq.
         * @memberof protoCmd
         * @interface IaddPetWaterReq
         * @property {boolean|null} [ad] addPetWaterReq ad
         */

        /**
         * Constructs a new addPetWaterReq.
         * @memberof protoCmd
         * @classdesc Represents an addPetWaterReq.
         * @implements IaddPetWaterReq
         * @constructor
         * @param {protoCmd.IaddPetWaterReq=} [properties] Properties to set
         */
        function addPetWaterReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * addPetWaterReq ad.
         * @member {boolean} ad
         * @memberof protoCmd.addPetWaterReq
         * @instance
         */
        addPetWaterReq.prototype.ad = false;

        /**
         * Creates a new addPetWaterReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.addPetWaterReq
         * @static
         * @param {protoCmd.IaddPetWaterReq=} [properties] Properties to set
         * @returns {protoCmd.addPetWaterReq} addPetWaterReq instance
         */
        addPetWaterReq.create = function create(properties) {
            return new addPetWaterReq(properties);
        };

        /**
         * Encodes the specified addPetWaterReq message. Does not implicitly {@link protoCmd.addPetWaterReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.addPetWaterReq
         * @static
         * @param {protoCmd.IaddPetWaterReq} message addPetWaterReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        addPetWaterReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.ad != null && Object.hasOwnProperty.call(message, "ad"))
                writer.uint32(/* id 1, wireType 0 =*/8).bool(message.ad);
            return writer;
        };

        /**
         * Encodes the specified addPetWaterReq message, length delimited. Does not implicitly {@link protoCmd.addPetWaterReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.addPetWaterReq
         * @static
         * @param {protoCmd.IaddPetWaterReq} message addPetWaterReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        addPetWaterReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an addPetWaterReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.addPetWaterReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.addPetWaterReq} addPetWaterReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        addPetWaterReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.addPetWaterReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.ad = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes an addPetWaterReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.addPetWaterReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.addPetWaterReq} addPetWaterReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        addPetWaterReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an addPetWaterReq message.
         * @function verify
         * @memberof protoCmd.addPetWaterReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        addPetWaterReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.ad != null && message.hasOwnProperty("ad"))
                if (typeof message.ad !== "boolean")
                    return "ad: boolean expected";
            return null;
        };

        /**
         * Creates an addPetWaterReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.addPetWaterReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.addPetWaterReq} addPetWaterReq
         */
        addPetWaterReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.addPetWaterReq)
                return object;
            var message = new $root.protoCmd.addPetWaterReq();
            if (object.ad != null)
                message.ad = Boolean(object.ad);
            return message;
        };

        /**
         * Creates a plain object from an addPetWaterReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.addPetWaterReq
         * @static
         * @param {protoCmd.addPetWaterReq} message addPetWaterReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        addPetWaterReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                object.ad = false;
            if (message.ad != null && message.hasOwnProperty("ad"))
                object.ad = message.ad;
            return object;
        };

        /**
         * Converts this addPetWaterReq to JSON.
         * @function toJSON
         * @memberof protoCmd.addPetWaterReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        addPetWaterReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return addPetWaterReq;
    })();

    protoCmd.addPetFoodMaxReq = (function() {

        /**
         * Properties of an addPetFoodMaxReq.
         * @memberof protoCmd
         * @interface IaddPetFoodMaxReq
         */

        /**
         * Constructs a new addPetFoodMaxReq.
         * @memberof protoCmd
         * @classdesc Represents an addPetFoodMaxReq.
         * @implements IaddPetFoodMaxReq
         * @constructor
         * @param {protoCmd.IaddPetFoodMaxReq=} [properties] Properties to set
         */
        function addPetFoodMaxReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new addPetFoodMaxReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.addPetFoodMaxReq
         * @static
         * @param {protoCmd.IaddPetFoodMaxReq=} [properties] Properties to set
         * @returns {protoCmd.addPetFoodMaxReq} addPetFoodMaxReq instance
         */
        addPetFoodMaxReq.create = function create(properties) {
            return new addPetFoodMaxReq(properties);
        };

        /**
         * Encodes the specified addPetFoodMaxReq message. Does not implicitly {@link protoCmd.addPetFoodMaxReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.addPetFoodMaxReq
         * @static
         * @param {protoCmd.IaddPetFoodMaxReq} message addPetFoodMaxReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        addPetFoodMaxReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified addPetFoodMaxReq message, length delimited. Does not implicitly {@link protoCmd.addPetFoodMaxReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.addPetFoodMaxReq
         * @static
         * @param {protoCmd.IaddPetFoodMaxReq} message addPetFoodMaxReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        addPetFoodMaxReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an addPetFoodMaxReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.addPetFoodMaxReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.addPetFoodMaxReq} addPetFoodMaxReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        addPetFoodMaxReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.addPetFoodMaxReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes an addPetFoodMaxReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.addPetFoodMaxReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.addPetFoodMaxReq} addPetFoodMaxReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        addPetFoodMaxReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an addPetFoodMaxReq message.
         * @function verify
         * @memberof protoCmd.addPetFoodMaxReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        addPetFoodMaxReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates an addPetFoodMaxReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.addPetFoodMaxReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.addPetFoodMaxReq} addPetFoodMaxReq
         */
        addPetFoodMaxReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.addPetFoodMaxReq)
                return object;
            return new $root.protoCmd.addPetFoodMaxReq();
        };

        /**
         * Creates a plain object from an addPetFoodMaxReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.addPetFoodMaxReq
         * @static
         * @param {protoCmd.addPetFoodMaxReq} message addPetFoodMaxReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        addPetFoodMaxReq.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this addPetFoodMaxReq to JSON.
         * @function toJSON
         * @memberof protoCmd.addPetFoodMaxReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        addPetFoodMaxReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return addPetFoodMaxReq;
    })();

    protoCmd.addPetWaterMaxReq = (function() {

        /**
         * Properties of an addPetWaterMaxReq.
         * @memberof protoCmd
         * @interface IaddPetWaterMaxReq
         */

        /**
         * Constructs a new addPetWaterMaxReq.
         * @memberof protoCmd
         * @classdesc Represents an addPetWaterMaxReq.
         * @implements IaddPetWaterMaxReq
         * @constructor
         * @param {protoCmd.IaddPetWaterMaxReq=} [properties] Properties to set
         */
        function addPetWaterMaxReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new addPetWaterMaxReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.addPetWaterMaxReq
         * @static
         * @param {protoCmd.IaddPetWaterMaxReq=} [properties] Properties to set
         * @returns {protoCmd.addPetWaterMaxReq} addPetWaterMaxReq instance
         */
        addPetWaterMaxReq.create = function create(properties) {
            return new addPetWaterMaxReq(properties);
        };

        /**
         * Encodes the specified addPetWaterMaxReq message. Does not implicitly {@link protoCmd.addPetWaterMaxReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.addPetWaterMaxReq
         * @static
         * @param {protoCmd.IaddPetWaterMaxReq} message addPetWaterMaxReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        addPetWaterMaxReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified addPetWaterMaxReq message, length delimited. Does not implicitly {@link protoCmd.addPetWaterMaxReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.addPetWaterMaxReq
         * @static
         * @param {protoCmd.IaddPetWaterMaxReq} message addPetWaterMaxReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        addPetWaterMaxReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an addPetWaterMaxReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.addPetWaterMaxReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.addPetWaterMaxReq} addPetWaterMaxReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        addPetWaterMaxReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.addPetWaterMaxReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes an addPetWaterMaxReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.addPetWaterMaxReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.addPetWaterMaxReq} addPetWaterMaxReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        addPetWaterMaxReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an addPetWaterMaxReq message.
         * @function verify
         * @memberof protoCmd.addPetWaterMaxReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        addPetWaterMaxReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates an addPetWaterMaxReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.addPetWaterMaxReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.addPetWaterMaxReq} addPetWaterMaxReq
         */
        addPetWaterMaxReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.addPetWaterMaxReq)
                return object;
            return new $root.protoCmd.addPetWaterMaxReq();
        };

        /**
         * Creates a plain object from an addPetWaterMaxReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.addPetWaterMaxReq
         * @static
         * @param {protoCmd.addPetWaterMaxReq} message addPetWaterMaxReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        addPetWaterMaxReq.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this addPetWaterMaxReq to JSON.
         * @function toJSON
         * @memberof protoCmd.addPetWaterMaxReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        addPetWaterMaxReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return addPetWaterMaxReq;
    })();

    protoCmd.sidebarRewardReq = (function() {

        /**
         * Properties of a sidebarRewardReq.
         * @memberof protoCmd
         * @interface IsidebarRewardReq
         */

        /**
         * Constructs a new sidebarRewardReq.
         * @memberof protoCmd
         * @classdesc Represents a sidebarRewardReq.
         * @implements IsidebarRewardReq
         * @constructor
         * @param {protoCmd.IsidebarRewardReq=} [properties] Properties to set
         */
        function sidebarRewardReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new sidebarRewardReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.sidebarRewardReq
         * @static
         * @param {protoCmd.IsidebarRewardReq=} [properties] Properties to set
         * @returns {protoCmd.sidebarRewardReq} sidebarRewardReq instance
         */
        sidebarRewardReq.create = function create(properties) {
            return new sidebarRewardReq(properties);
        };

        /**
         * Encodes the specified sidebarRewardReq message. Does not implicitly {@link protoCmd.sidebarRewardReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.sidebarRewardReq
         * @static
         * @param {protoCmd.IsidebarRewardReq} message sidebarRewardReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        sidebarRewardReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified sidebarRewardReq message, length delimited. Does not implicitly {@link protoCmd.sidebarRewardReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.sidebarRewardReq
         * @static
         * @param {protoCmd.IsidebarRewardReq} message sidebarRewardReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        sidebarRewardReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a sidebarRewardReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.sidebarRewardReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.sidebarRewardReq} sidebarRewardReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        sidebarRewardReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.sidebarRewardReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a sidebarRewardReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.sidebarRewardReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.sidebarRewardReq} sidebarRewardReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        sidebarRewardReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a sidebarRewardReq message.
         * @function verify
         * @memberof protoCmd.sidebarRewardReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        sidebarRewardReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates a sidebarRewardReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.sidebarRewardReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.sidebarRewardReq} sidebarRewardReq
         */
        sidebarRewardReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.sidebarRewardReq)
                return object;
            return new $root.protoCmd.sidebarRewardReq();
        };

        /**
         * Creates a plain object from a sidebarRewardReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.sidebarRewardReq
         * @static
         * @param {protoCmd.sidebarRewardReq} message sidebarRewardReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        sidebarRewardReq.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this sidebarRewardReq to JSON.
         * @function toJSON
         * @memberof protoCmd.sidebarRewardReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        sidebarRewardReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return sidebarRewardReq;
    })();

    protoCmd.cdkUseReq = (function() {

        /**
         * Properties of a cdkUseReq.
         * @memberof protoCmd
         * @interface IcdkUseReq
         * @property {string|null} [cdk] cdkUseReq cdk
         */

        /**
         * Constructs a new cdkUseReq.
         * @memberof protoCmd
         * @classdesc Represents a cdkUseReq.
         * @implements IcdkUseReq
         * @constructor
         * @param {protoCmd.IcdkUseReq=} [properties] Properties to set
         */
        function cdkUseReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * cdkUseReq cdk.
         * @member {string} cdk
         * @memberof protoCmd.cdkUseReq
         * @instance
         */
        cdkUseReq.prototype.cdk = "";

        /**
         * Creates a new cdkUseReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.cdkUseReq
         * @static
         * @param {protoCmd.IcdkUseReq=} [properties] Properties to set
         * @returns {protoCmd.cdkUseReq} cdkUseReq instance
         */
        cdkUseReq.create = function create(properties) {
            return new cdkUseReq(properties);
        };

        /**
         * Encodes the specified cdkUseReq message. Does not implicitly {@link protoCmd.cdkUseReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.cdkUseReq
         * @static
         * @param {protoCmd.IcdkUseReq} message cdkUseReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        cdkUseReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.cdk != null && Object.hasOwnProperty.call(message, "cdk"))
                writer.uint32(/* id 1, wireType 2 =*/10).string(message.cdk);
            return writer;
        };

        /**
         * Encodes the specified cdkUseReq message, length delimited. Does not implicitly {@link protoCmd.cdkUseReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.cdkUseReq
         * @static
         * @param {protoCmd.IcdkUseReq} message cdkUseReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        cdkUseReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a cdkUseReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.cdkUseReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.cdkUseReq} cdkUseReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        cdkUseReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.cdkUseReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.cdk = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a cdkUseReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.cdkUseReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.cdkUseReq} cdkUseReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        cdkUseReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a cdkUseReq message.
         * @function verify
         * @memberof protoCmd.cdkUseReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        cdkUseReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.cdk != null && message.hasOwnProperty("cdk"))
                if (!$util.isString(message.cdk))
                    return "cdk: string expected";
            return null;
        };

        /**
         * Creates a cdkUseReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.cdkUseReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.cdkUseReq} cdkUseReq
         */
        cdkUseReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.cdkUseReq)
                return object;
            var message = new $root.protoCmd.cdkUseReq();
            if (object.cdk != null)
                message.cdk = String(object.cdk);
            return message;
        };

        /**
         * Creates a plain object from a cdkUseReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.cdkUseReq
         * @static
         * @param {protoCmd.cdkUseReq} message cdkUseReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        cdkUseReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                object.cdk = "";
            if (message.cdk != null && message.hasOwnProperty("cdk"))
                object.cdk = message.cdk;
            return object;
        };

        /**
         * Converts this cdkUseReq to JSON.
         * @function toJSON
         * @memberof protoCmd.cdkUseReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        cdkUseReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return cdkUseReq;
    })();

    protoCmd.cdkUseRes = (function() {

        /**
         * Properties of a cdkUseRes.
         * @memberof protoCmd
         * @interface IcdkUseRes
         * @property {number|Long|null} [cdkCid] cdkUseRes cdkCid
         */

        /**
         * Constructs a new cdkUseRes.
         * @memberof protoCmd
         * @classdesc Represents a cdkUseRes.
         * @implements IcdkUseRes
         * @constructor
         * @param {protoCmd.IcdkUseRes=} [properties] Properties to set
         */
        function cdkUseRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * cdkUseRes cdkCid.
         * @member {number|Long} cdkCid
         * @memberof protoCmd.cdkUseRes
         * @instance
         */
        cdkUseRes.prototype.cdkCid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new cdkUseRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.cdkUseRes
         * @static
         * @param {protoCmd.IcdkUseRes=} [properties] Properties to set
         * @returns {protoCmd.cdkUseRes} cdkUseRes instance
         */
        cdkUseRes.create = function create(properties) {
            return new cdkUseRes(properties);
        };

        /**
         * Encodes the specified cdkUseRes message. Does not implicitly {@link protoCmd.cdkUseRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.cdkUseRes
         * @static
         * @param {protoCmd.IcdkUseRes} message cdkUseRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        cdkUseRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.cdkCid != null && Object.hasOwnProperty.call(message, "cdkCid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.cdkCid);
            return writer;
        };

        /**
         * Encodes the specified cdkUseRes message, length delimited. Does not implicitly {@link protoCmd.cdkUseRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.cdkUseRes
         * @static
         * @param {protoCmd.IcdkUseRes} message cdkUseRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        cdkUseRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a cdkUseRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.cdkUseRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.cdkUseRes} cdkUseRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        cdkUseRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.cdkUseRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.cdkCid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a cdkUseRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.cdkUseRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.cdkUseRes} cdkUseRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        cdkUseRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a cdkUseRes message.
         * @function verify
         * @memberof protoCmd.cdkUseRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        cdkUseRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.cdkCid != null && message.hasOwnProperty("cdkCid"))
                if (!$util.isInteger(message.cdkCid) && !(message.cdkCid && $util.isInteger(message.cdkCid.low) && $util.isInteger(message.cdkCid.high)))
                    return "cdkCid: integer|Long expected";
            return null;
        };

        /**
         * Creates a cdkUseRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.cdkUseRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.cdkUseRes} cdkUseRes
         */
        cdkUseRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.cdkUseRes)
                return object;
            var message = new $root.protoCmd.cdkUseRes();
            if (object.cdkCid != null)
                if ($util.Long)
                    (message.cdkCid = $util.Long.fromValue(object.cdkCid)).unsigned = true;
                else if (typeof object.cdkCid === "string")
                    message.cdkCid = parseInt(object.cdkCid, 10);
                else if (typeof object.cdkCid === "number")
                    message.cdkCid = object.cdkCid;
                else if (typeof object.cdkCid === "object")
                    message.cdkCid = new $util.LongBits(object.cdkCid.low >>> 0, object.cdkCid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a cdkUseRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.cdkUseRes
         * @static
         * @param {protoCmd.cdkUseRes} message cdkUseRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        cdkUseRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.cdkCid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.cdkCid = options.longs === String ? "0" : 0;
            if (message.cdkCid != null && message.hasOwnProperty("cdkCid"))
                if (typeof message.cdkCid === "number")
                    object.cdkCid = options.longs === String ? String(message.cdkCid) : message.cdkCid;
                else
                    object.cdkCid = options.longs === String ? $util.Long.prototype.toString.call(message.cdkCid) : options.longs === Number ? new $util.LongBits(message.cdkCid.low >>> 0, message.cdkCid.high >>> 0).toNumber(true) : message.cdkCid;
            return object;
        };

        /**
         * Converts this cdkUseRes to JSON.
         * @function toJSON
         * @memberof protoCmd.cdkUseRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        cdkUseRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return cdkUseRes;
    })();

    protoCmd.shopSyn = (function() {

        /**
         * Properties of a shopSyn.
         * @memberof protoCmd
         * @interface IshopSyn
         * @property {Array.<protoCmd.IcommodityRes>|null} [commodityList] shopSyn commodityList
         */

        /**
         * Constructs a new shopSyn.
         * @memberof protoCmd
         * @classdesc Represents a shopSyn.
         * @implements IshopSyn
         * @constructor
         * @param {protoCmd.IshopSyn=} [properties] Properties to set
         */
        function shopSyn(properties) {
            this.commodityList = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * shopSyn commodityList.
         * @member {Array.<protoCmd.IcommodityRes>} commodityList
         * @memberof protoCmd.shopSyn
         * @instance
         */
        shopSyn.prototype.commodityList = $util.emptyArray;

        /**
         * Creates a new shopSyn instance using the specified properties.
         * @function create
         * @memberof protoCmd.shopSyn
         * @static
         * @param {protoCmd.IshopSyn=} [properties] Properties to set
         * @returns {protoCmd.shopSyn} shopSyn instance
         */
        shopSyn.create = function create(properties) {
            return new shopSyn(properties);
        };

        /**
         * Encodes the specified shopSyn message. Does not implicitly {@link protoCmd.shopSyn.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.shopSyn
         * @static
         * @param {protoCmd.IshopSyn} message shopSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        shopSyn.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.commodityList != null && message.commodityList.length)
                for (var i = 0; i < message.commodityList.length; ++i)
                    $root.protoCmd.commodityRes.encode(message.commodityList[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified shopSyn message, length delimited. Does not implicitly {@link protoCmd.shopSyn.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.shopSyn
         * @static
         * @param {protoCmd.IshopSyn} message shopSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        shopSyn.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a shopSyn message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.shopSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.shopSyn} shopSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        shopSyn.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.shopSyn();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    if (!(message.commodityList && message.commodityList.length))
                        message.commodityList = [];
                    message.commodityList.push($root.protoCmd.commodityRes.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a shopSyn message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.shopSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.shopSyn} shopSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        shopSyn.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a shopSyn message.
         * @function verify
         * @memberof protoCmd.shopSyn
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        shopSyn.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.commodityList != null && message.hasOwnProperty("commodityList")) {
                if (!Array.isArray(message.commodityList))
                    return "commodityList: array expected";
                for (var i = 0; i < message.commodityList.length; ++i) {
                    var error = $root.protoCmd.commodityRes.verify(message.commodityList[i]);
                    if (error)
                        return "commodityList." + error;
                }
            }
            return null;
        };

        /**
         * Creates a shopSyn message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.shopSyn
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.shopSyn} shopSyn
         */
        shopSyn.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.shopSyn)
                return object;
            var message = new $root.protoCmd.shopSyn();
            if (object.commodityList) {
                if (!Array.isArray(object.commodityList))
                    throw TypeError(".protoCmd.shopSyn.commodityList: array expected");
                message.commodityList = [];
                for (var i = 0; i < object.commodityList.length; ++i) {
                    if (typeof object.commodityList[i] !== "object")
                        throw TypeError(".protoCmd.shopSyn.commodityList: object expected");
                    message.commodityList[i] = $root.protoCmd.commodityRes.fromObject(object.commodityList[i]);
                }
            }
            return message;
        };

        /**
         * Creates a plain object from a shopSyn message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.shopSyn
         * @static
         * @param {protoCmd.shopSyn} message shopSyn
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        shopSyn.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.arrays || options.defaults)
                object.commodityList = [];
            if (message.commodityList && message.commodityList.length) {
                object.commodityList = [];
                for (var j = 0; j < message.commodityList.length; ++j)
                    object.commodityList[j] = $root.protoCmd.commodityRes.toObject(message.commodityList[j], options);
            }
            return object;
        };

        /**
         * Converts this shopSyn to JSON.
         * @function toJSON
         * @memberof protoCmd.shopSyn
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        shopSyn.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return shopSyn;
    })();

    protoCmd.commodityReq = (function() {

        /**
         * Properties of a commodityReq.
         * @memberof protoCmd
         * @interface IcommodityReq
         * @property {number|null} [cid] commodityReq cid
         */

        /**
         * Constructs a new commodityReq.
         * @memberof protoCmd
         * @classdesc Represents a commodityReq.
         * @implements IcommodityReq
         * @constructor
         * @param {protoCmd.IcommodityReq=} [properties] Properties to set
         */
        function commodityReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * commodityReq cid.
         * @member {number} cid
         * @memberof protoCmd.commodityReq
         * @instance
         */
        commodityReq.prototype.cid = 0;

        /**
         * Creates a new commodityReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.commodityReq
         * @static
         * @param {protoCmd.IcommodityReq=} [properties] Properties to set
         * @returns {protoCmd.commodityReq} commodityReq instance
         */
        commodityReq.create = function create(properties) {
            return new commodityReq(properties);
        };

        /**
         * Encodes the specified commodityReq message. Does not implicitly {@link protoCmd.commodityReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.commodityReq
         * @static
         * @param {protoCmd.IcommodityReq} message commodityReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        commodityReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.cid != null && Object.hasOwnProperty.call(message, "cid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.cid);
            return writer;
        };

        /**
         * Encodes the specified commodityReq message, length delimited. Does not implicitly {@link protoCmd.commodityReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.commodityReq
         * @static
         * @param {protoCmd.IcommodityReq} message commodityReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        commodityReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a commodityReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.commodityReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.commodityReq} commodityReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        commodityReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.commodityReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.cid = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a commodityReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.commodityReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.commodityReq} commodityReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        commodityReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a commodityReq message.
         * @function verify
         * @memberof protoCmd.commodityReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        commodityReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (!$util.isInteger(message.cid))
                    return "cid: integer expected";
            return null;
        };

        /**
         * Creates a commodityReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.commodityReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.commodityReq} commodityReq
         */
        commodityReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.commodityReq)
                return object;
            var message = new $root.protoCmd.commodityReq();
            if (object.cid != null)
                message.cid = object.cid >>> 0;
            return message;
        };

        /**
         * Creates a plain object from a commodityReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.commodityReq
         * @static
         * @param {protoCmd.commodityReq} message commodityReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        commodityReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                object.cid = 0;
            if (message.cid != null && message.hasOwnProperty("cid"))
                object.cid = message.cid;
            return object;
        };

        /**
         * Converts this commodityReq to JSON.
         * @function toJSON
         * @memberof protoCmd.commodityReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        commodityReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return commodityReq;
    })();

    protoCmd.commodityRes = (function() {

        /**
         * Properties of a commodityRes.
         * @memberof protoCmd
         * @interface IcommodityRes
         * @property {number|null} [cid] commodityRes cid
         * @property {number|null} [buyCount] commodityRes buyCount
         */

        /**
         * Constructs a new commodityRes.
         * @memberof protoCmd
         * @classdesc Represents a commodityRes.
         * @implements IcommodityRes
         * @constructor
         * @param {protoCmd.IcommodityRes=} [properties] Properties to set
         */
        function commodityRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * commodityRes cid.
         * @member {number} cid
         * @memberof protoCmd.commodityRes
         * @instance
         */
        commodityRes.prototype.cid = 0;

        /**
         * commodityRes buyCount.
         * @member {number} buyCount
         * @memberof protoCmd.commodityRes
         * @instance
         */
        commodityRes.prototype.buyCount = 0;

        /**
         * Creates a new commodityRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.commodityRes
         * @static
         * @param {protoCmd.IcommodityRes=} [properties] Properties to set
         * @returns {protoCmd.commodityRes} commodityRes instance
         */
        commodityRes.create = function create(properties) {
            return new commodityRes(properties);
        };

        /**
         * Encodes the specified commodityRes message. Does not implicitly {@link protoCmd.commodityRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.commodityRes
         * @static
         * @param {protoCmd.IcommodityRes} message commodityRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        commodityRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.cid != null && Object.hasOwnProperty.call(message, "cid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.cid);
            if (message.buyCount != null && Object.hasOwnProperty.call(message, "buyCount"))
                writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.buyCount);
            return writer;
        };

        /**
         * Encodes the specified commodityRes message, length delimited. Does not implicitly {@link protoCmd.commodityRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.commodityRes
         * @static
         * @param {protoCmd.IcommodityRes} message commodityRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        commodityRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a commodityRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.commodityRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.commodityRes} commodityRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        commodityRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.commodityRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.cid = reader.uint32();
                    break;
                case 2:
                    message.buyCount = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a commodityRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.commodityRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.commodityRes} commodityRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        commodityRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a commodityRes message.
         * @function verify
         * @memberof protoCmd.commodityRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        commodityRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (!$util.isInteger(message.cid))
                    return "cid: integer expected";
            if (message.buyCount != null && message.hasOwnProperty("buyCount"))
                if (!$util.isInteger(message.buyCount))
                    return "buyCount: integer expected";
            return null;
        };

        /**
         * Creates a commodityRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.commodityRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.commodityRes} commodityRes
         */
        commodityRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.commodityRes)
                return object;
            var message = new $root.protoCmd.commodityRes();
            if (object.cid != null)
                message.cid = object.cid >>> 0;
            if (object.buyCount != null)
                message.buyCount = object.buyCount >>> 0;
            return message;
        };

        /**
         * Creates a plain object from a commodityRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.commodityRes
         * @static
         * @param {protoCmd.commodityRes} message commodityRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        commodityRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                object.cid = 0;
                object.buyCount = 0;
            }
            if (message.cid != null && message.hasOwnProperty("cid"))
                object.cid = message.cid;
            if (message.buyCount != null && message.hasOwnProperty("buyCount"))
                object.buyCount = message.buyCount;
            return object;
        };

        /**
         * Converts this commodityRes to JSON.
         * @function toJSON
         * @memberof protoCmd.commodityRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        commodityRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return commodityRes;
    })();

    protoCmd.taskSyn = (function() {

        /**
         * Properties of a taskSyn.
         * @memberof protoCmd
         * @interface ItaskSyn
         * @property {Array.<protoCmd.Itaskres>|null} [taskList] taskSyn taskList
         */

        /**
         * Constructs a new taskSyn.
         * @memberof protoCmd
         * @classdesc Represents a taskSyn.
         * @implements ItaskSyn
         * @constructor
         * @param {protoCmd.ItaskSyn=} [properties] Properties to set
         */
        function taskSyn(properties) {
            this.taskList = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * taskSyn taskList.
         * @member {Array.<protoCmd.Itaskres>} taskList
         * @memberof protoCmd.taskSyn
         * @instance
         */
        taskSyn.prototype.taskList = $util.emptyArray;

        /**
         * Creates a new taskSyn instance using the specified properties.
         * @function create
         * @memberof protoCmd.taskSyn
         * @static
         * @param {protoCmd.ItaskSyn=} [properties] Properties to set
         * @returns {protoCmd.taskSyn} taskSyn instance
         */
        taskSyn.create = function create(properties) {
            return new taskSyn(properties);
        };

        /**
         * Encodes the specified taskSyn message. Does not implicitly {@link protoCmd.taskSyn.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.taskSyn
         * @static
         * @param {protoCmd.ItaskSyn} message taskSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        taskSyn.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.taskList != null && message.taskList.length)
                for (var i = 0; i < message.taskList.length; ++i)
                    $root.protoCmd.taskres.encode(message.taskList[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified taskSyn message, length delimited. Does not implicitly {@link protoCmd.taskSyn.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.taskSyn
         * @static
         * @param {protoCmd.ItaskSyn} message taskSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        taskSyn.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a taskSyn message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.taskSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.taskSyn} taskSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        taskSyn.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.taskSyn();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    if (!(message.taskList && message.taskList.length))
                        message.taskList = [];
                    message.taskList.push($root.protoCmd.taskres.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a taskSyn message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.taskSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.taskSyn} taskSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        taskSyn.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a taskSyn message.
         * @function verify
         * @memberof protoCmd.taskSyn
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        taskSyn.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.taskList != null && message.hasOwnProperty("taskList")) {
                if (!Array.isArray(message.taskList))
                    return "taskList: array expected";
                for (var i = 0; i < message.taskList.length; ++i) {
                    var error = $root.protoCmd.taskres.verify(message.taskList[i]);
                    if (error)
                        return "taskList." + error;
                }
            }
            return null;
        };

        /**
         * Creates a taskSyn message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.taskSyn
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.taskSyn} taskSyn
         */
        taskSyn.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.taskSyn)
                return object;
            var message = new $root.protoCmd.taskSyn();
            if (object.taskList) {
                if (!Array.isArray(object.taskList))
                    throw TypeError(".protoCmd.taskSyn.taskList: array expected");
                message.taskList = [];
                for (var i = 0; i < object.taskList.length; ++i) {
                    if (typeof object.taskList[i] !== "object")
                        throw TypeError(".protoCmd.taskSyn.taskList: object expected");
                    message.taskList[i] = $root.protoCmd.taskres.fromObject(object.taskList[i]);
                }
            }
            return message;
        };

        /**
         * Creates a plain object from a taskSyn message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.taskSyn
         * @static
         * @param {protoCmd.taskSyn} message taskSyn
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        taskSyn.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.arrays || options.defaults)
                object.taskList = [];
            if (message.taskList && message.taskList.length) {
                object.taskList = [];
                for (var j = 0; j < message.taskList.length; ++j)
                    object.taskList[j] = $root.protoCmd.taskres.toObject(message.taskList[j], options);
            }
            return object;
        };

        /**
         * Converts this taskSyn to JSON.
         * @function toJSON
         * @memberof protoCmd.taskSyn
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        taskSyn.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return taskSyn;
    })();

    protoCmd.taskreq = (function() {

        /**
         * Properties of a taskreq.
         * @memberof protoCmd
         * @interface Itaskreq
         * @property {number|null} [cid] taskreq cid
         */

        /**
         * Constructs a new taskreq.
         * @memberof protoCmd
         * @classdesc Represents a taskreq.
         * @implements Itaskreq
         * @constructor
         * @param {protoCmd.Itaskreq=} [properties] Properties to set
         */
        function taskreq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * taskreq cid.
         * @member {number} cid
         * @memberof protoCmd.taskreq
         * @instance
         */
        taskreq.prototype.cid = 0;

        /**
         * Creates a new taskreq instance using the specified properties.
         * @function create
         * @memberof protoCmd.taskreq
         * @static
         * @param {protoCmd.Itaskreq=} [properties] Properties to set
         * @returns {protoCmd.taskreq} taskreq instance
         */
        taskreq.create = function create(properties) {
            return new taskreq(properties);
        };

        /**
         * Encodes the specified taskreq message. Does not implicitly {@link protoCmd.taskreq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.taskreq
         * @static
         * @param {protoCmd.Itaskreq} message taskreq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        taskreq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.cid != null && Object.hasOwnProperty.call(message, "cid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.cid);
            return writer;
        };

        /**
         * Encodes the specified taskreq message, length delimited. Does not implicitly {@link protoCmd.taskreq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.taskreq
         * @static
         * @param {protoCmd.Itaskreq} message taskreq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        taskreq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a taskreq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.taskreq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.taskreq} taskreq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        taskreq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.taskreq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.cid = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a taskreq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.taskreq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.taskreq} taskreq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        taskreq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a taskreq message.
         * @function verify
         * @memberof protoCmd.taskreq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        taskreq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (!$util.isInteger(message.cid))
                    return "cid: integer expected";
            return null;
        };

        /**
         * Creates a taskreq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.taskreq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.taskreq} taskreq
         */
        taskreq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.taskreq)
                return object;
            var message = new $root.protoCmd.taskreq();
            if (object.cid != null)
                message.cid = object.cid >>> 0;
            return message;
        };

        /**
         * Creates a plain object from a taskreq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.taskreq
         * @static
         * @param {protoCmd.taskreq} message taskreq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        taskreq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                object.cid = 0;
            if (message.cid != null && message.hasOwnProperty("cid"))
                object.cid = message.cid;
            return object;
        };

        /**
         * Converts this taskreq to JSON.
         * @function toJSON
         * @memberof protoCmd.taskreq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        taskreq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return taskreq;
    })();

    protoCmd.taskres = (function() {

        /**
         * Properties of a taskres.
         * @memberof protoCmd
         * @interface Itaskres
         * @property {number|null} [cid] taskres cid
         * @property {number|null} [arg] taskres arg
         * @property {boolean|null} [state] taskres state
         */

        /**
         * Constructs a new taskres.
         * @memberof protoCmd
         * @classdesc Represents a taskres.
         * @implements Itaskres
         * @constructor
         * @param {protoCmd.Itaskres=} [properties] Properties to set
         */
        function taskres(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * taskres cid.
         * @member {number} cid
         * @memberof protoCmd.taskres
         * @instance
         */
        taskres.prototype.cid = 0;

        /**
         * taskres arg.
         * @member {number} arg
         * @memberof protoCmd.taskres
         * @instance
         */
        taskres.prototype.arg = 0;

        /**
         * taskres state.
         * @member {boolean} state
         * @memberof protoCmd.taskres
         * @instance
         */
        taskres.prototype.state = false;

        /**
         * Creates a new taskres instance using the specified properties.
         * @function create
         * @memberof protoCmd.taskres
         * @static
         * @param {protoCmd.Itaskres=} [properties] Properties to set
         * @returns {protoCmd.taskres} taskres instance
         */
        taskres.create = function create(properties) {
            return new taskres(properties);
        };

        /**
         * Encodes the specified taskres message. Does not implicitly {@link protoCmd.taskres.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.taskres
         * @static
         * @param {protoCmd.Itaskres} message taskres message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        taskres.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.cid != null && Object.hasOwnProperty.call(message, "cid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.cid);
            if (message.arg != null && Object.hasOwnProperty.call(message, "arg"))
                writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.arg);
            if (message.state != null && Object.hasOwnProperty.call(message, "state"))
                writer.uint32(/* id 3, wireType 0 =*/24).bool(message.state);
            return writer;
        };

        /**
         * Encodes the specified taskres message, length delimited. Does not implicitly {@link protoCmd.taskres.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.taskres
         * @static
         * @param {protoCmd.Itaskres} message taskres message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        taskres.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a taskres message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.taskres
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.taskres} taskres
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        taskres.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.taskres();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.cid = reader.uint32();
                    break;
                case 2:
                    message.arg = reader.uint32();
                    break;
                case 3:
                    message.state = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a taskres message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.taskres
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.taskres} taskres
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        taskres.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a taskres message.
         * @function verify
         * @memberof protoCmd.taskres
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        taskres.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (!$util.isInteger(message.cid))
                    return "cid: integer expected";
            if (message.arg != null && message.hasOwnProperty("arg"))
                if (!$util.isInteger(message.arg))
                    return "arg: integer expected";
            if (message.state != null && message.hasOwnProperty("state"))
                if (typeof message.state !== "boolean")
                    return "state: boolean expected";
            return null;
        };

        /**
         * Creates a taskres message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.taskres
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.taskres} taskres
         */
        taskres.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.taskres)
                return object;
            var message = new $root.protoCmd.taskres();
            if (object.cid != null)
                message.cid = object.cid >>> 0;
            if (object.arg != null)
                message.arg = object.arg >>> 0;
            if (object.state != null)
                message.state = Boolean(object.state);
            return message;
        };

        /**
         * Creates a plain object from a taskres message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.taskres
         * @static
         * @param {protoCmd.taskres} message taskres
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        taskres.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                object.cid = 0;
                object.arg = 0;
                object.state = false;
            }
            if (message.cid != null && message.hasOwnProperty("cid"))
                object.cid = message.cid;
            if (message.arg != null && message.hasOwnProperty("arg"))
                object.arg = message.arg;
            if (message.state != null && message.hasOwnProperty("state"))
                object.state = message.state;
            return object;
        };

        /**
         * Converts this taskres to JSON.
         * @function toJSON
         * @memberof protoCmd.taskres
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        taskres.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return taskres;
    })();

    protoCmd.taskBoxreq = (function() {

        /**
         * Properties of a taskBoxreq.
         * @memberof protoCmd
         * @interface ItaskBoxreq
         * @property {number|null} [cid] taskBoxreq cid
         */

        /**
         * Constructs a new taskBoxreq.
         * @memberof protoCmd
         * @classdesc Represents a taskBoxreq.
         * @implements ItaskBoxreq
         * @constructor
         * @param {protoCmd.ItaskBoxreq=} [properties] Properties to set
         */
        function taskBoxreq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * taskBoxreq cid.
         * @member {number} cid
         * @memberof protoCmd.taskBoxreq
         * @instance
         */
        taskBoxreq.prototype.cid = 0;

        /**
         * Creates a new taskBoxreq instance using the specified properties.
         * @function create
         * @memberof protoCmd.taskBoxreq
         * @static
         * @param {protoCmd.ItaskBoxreq=} [properties] Properties to set
         * @returns {protoCmd.taskBoxreq} taskBoxreq instance
         */
        taskBoxreq.create = function create(properties) {
            return new taskBoxreq(properties);
        };

        /**
         * Encodes the specified taskBoxreq message. Does not implicitly {@link protoCmd.taskBoxreq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.taskBoxreq
         * @static
         * @param {protoCmd.ItaskBoxreq} message taskBoxreq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        taskBoxreq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.cid != null && Object.hasOwnProperty.call(message, "cid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.cid);
            return writer;
        };

        /**
         * Encodes the specified taskBoxreq message, length delimited. Does not implicitly {@link protoCmd.taskBoxreq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.taskBoxreq
         * @static
         * @param {protoCmd.ItaskBoxreq} message taskBoxreq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        taskBoxreq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a taskBoxreq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.taskBoxreq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.taskBoxreq} taskBoxreq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        taskBoxreq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.taskBoxreq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.cid = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a taskBoxreq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.taskBoxreq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.taskBoxreq} taskBoxreq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        taskBoxreq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a taskBoxreq message.
         * @function verify
         * @memberof protoCmd.taskBoxreq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        taskBoxreq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (!$util.isInteger(message.cid))
                    return "cid: integer expected";
            return null;
        };

        /**
         * Creates a taskBoxreq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.taskBoxreq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.taskBoxreq} taskBoxreq
         */
        taskBoxreq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.taskBoxreq)
                return object;
            var message = new $root.protoCmd.taskBoxreq();
            if (object.cid != null)
                message.cid = object.cid >>> 0;
            return message;
        };

        /**
         * Creates a plain object from a taskBoxreq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.taskBoxreq
         * @static
         * @param {protoCmd.taskBoxreq} message taskBoxreq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        taskBoxreq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                object.cid = 0;
            if (message.cid != null && message.hasOwnProperty("cid"))
                object.cid = message.cid;
            return object;
        };

        /**
         * Converts this taskBoxreq to JSON.
         * @function toJSON
         * @memberof protoCmd.taskBoxreq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        taskBoxreq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return taskBoxreq;
    })();

    protoCmd.taskBoxSyn = (function() {

        /**
         * Properties of a taskBoxSyn.
         * @memberof protoCmd
         * @interface ItaskBoxSyn
         * @property {Array.<number>|null} [cidList] taskBoxSyn cidList
         */

        /**
         * Constructs a new taskBoxSyn.
         * @memberof protoCmd
         * @classdesc Represents a taskBoxSyn.
         * @implements ItaskBoxSyn
         * @constructor
         * @param {protoCmd.ItaskBoxSyn=} [properties] Properties to set
         */
        function taskBoxSyn(properties) {
            this.cidList = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * taskBoxSyn cidList.
         * @member {Array.<number>} cidList
         * @memberof protoCmd.taskBoxSyn
         * @instance
         */
        taskBoxSyn.prototype.cidList = $util.emptyArray;

        /**
         * Creates a new taskBoxSyn instance using the specified properties.
         * @function create
         * @memberof protoCmd.taskBoxSyn
         * @static
         * @param {protoCmd.ItaskBoxSyn=} [properties] Properties to set
         * @returns {protoCmd.taskBoxSyn} taskBoxSyn instance
         */
        taskBoxSyn.create = function create(properties) {
            return new taskBoxSyn(properties);
        };

        /**
         * Encodes the specified taskBoxSyn message. Does not implicitly {@link protoCmd.taskBoxSyn.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.taskBoxSyn
         * @static
         * @param {protoCmd.ItaskBoxSyn} message taskBoxSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        taskBoxSyn.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.cidList != null && message.cidList.length) {
                writer.uint32(/* id 1, wireType 2 =*/10).fork();
                for (var i = 0; i < message.cidList.length; ++i)
                    writer.uint32(message.cidList[i]);
                writer.ldelim();
            }
            return writer;
        };

        /**
         * Encodes the specified taskBoxSyn message, length delimited. Does not implicitly {@link protoCmd.taskBoxSyn.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.taskBoxSyn
         * @static
         * @param {protoCmd.ItaskBoxSyn} message taskBoxSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        taskBoxSyn.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a taskBoxSyn message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.taskBoxSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.taskBoxSyn} taskBoxSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        taskBoxSyn.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.taskBoxSyn();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    if (!(message.cidList && message.cidList.length))
                        message.cidList = [];
                    if ((tag & 7) === 2) {
                        var end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2)
                            message.cidList.push(reader.uint32());
                    } else
                        message.cidList.push(reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a taskBoxSyn message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.taskBoxSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.taskBoxSyn} taskBoxSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        taskBoxSyn.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a taskBoxSyn message.
         * @function verify
         * @memberof protoCmd.taskBoxSyn
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        taskBoxSyn.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.cidList != null && message.hasOwnProperty("cidList")) {
                if (!Array.isArray(message.cidList))
                    return "cidList: array expected";
                for (var i = 0; i < message.cidList.length; ++i)
                    if (!$util.isInteger(message.cidList[i]))
                        return "cidList: integer[] expected";
            }
            return null;
        };

        /**
         * Creates a taskBoxSyn message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.taskBoxSyn
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.taskBoxSyn} taskBoxSyn
         */
        taskBoxSyn.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.taskBoxSyn)
                return object;
            var message = new $root.protoCmd.taskBoxSyn();
            if (object.cidList) {
                if (!Array.isArray(object.cidList))
                    throw TypeError(".protoCmd.taskBoxSyn.cidList: array expected");
                message.cidList = [];
                for (var i = 0; i < object.cidList.length; ++i)
                    message.cidList[i] = object.cidList[i] >>> 0;
            }
            return message;
        };

        /**
         * Creates a plain object from a taskBoxSyn message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.taskBoxSyn
         * @static
         * @param {protoCmd.taskBoxSyn} message taskBoxSyn
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        taskBoxSyn.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.arrays || options.defaults)
                object.cidList = [];
            if (message.cidList && message.cidList.length) {
                object.cidList = [];
                for (var j = 0; j < message.cidList.length; ++j)
                    object.cidList[j] = message.cidList[j];
            }
            return object;
        };

        /**
         * Converts this taskBoxSyn to JSON.
         * @function toJSON
         * @memberof protoCmd.taskBoxSyn
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        taskBoxSyn.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return taskBoxSyn;
    })();

    protoCmd.globalHeartPing = (function() {

        /**
         * Properties of a globalHeartPing.
         * @memberof protoCmd
         * @interface IglobalHeartPing
         * @property {number|Long|null} [sign] globalHeartPing sign
         */

        /**
         * Constructs a new globalHeartPing.
         * @memberof protoCmd
         * @classdesc Represents a globalHeartPing.
         * @implements IglobalHeartPing
         * @constructor
         * @param {protoCmd.IglobalHeartPing=} [properties] Properties to set
         */
        function globalHeartPing(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * globalHeartPing sign.
         * @member {number|Long} sign
         * @memberof protoCmd.globalHeartPing
         * @instance
         */
        globalHeartPing.prototype.sign = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new globalHeartPing instance using the specified properties.
         * @function create
         * @memberof protoCmd.globalHeartPing
         * @static
         * @param {protoCmd.IglobalHeartPing=} [properties] Properties to set
         * @returns {protoCmd.globalHeartPing} globalHeartPing instance
         */
        globalHeartPing.create = function create(properties) {
            return new globalHeartPing(properties);
        };

        /**
         * Encodes the specified globalHeartPing message. Does not implicitly {@link protoCmd.globalHeartPing.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.globalHeartPing
         * @static
         * @param {protoCmd.IglobalHeartPing} message globalHeartPing message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        globalHeartPing.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.sign != null && Object.hasOwnProperty.call(message, "sign"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.sign);
            return writer;
        };

        /**
         * Encodes the specified globalHeartPing message, length delimited. Does not implicitly {@link protoCmd.globalHeartPing.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.globalHeartPing
         * @static
         * @param {protoCmd.IglobalHeartPing} message globalHeartPing message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        globalHeartPing.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a globalHeartPing message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.globalHeartPing
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.globalHeartPing} globalHeartPing
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        globalHeartPing.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.globalHeartPing();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.sign = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a globalHeartPing message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.globalHeartPing
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.globalHeartPing} globalHeartPing
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        globalHeartPing.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a globalHeartPing message.
         * @function verify
         * @memberof protoCmd.globalHeartPing
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        globalHeartPing.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.sign != null && message.hasOwnProperty("sign"))
                if (!$util.isInteger(message.sign) && !(message.sign && $util.isInteger(message.sign.low) && $util.isInteger(message.sign.high)))
                    return "sign: integer|Long expected";
            return null;
        };

        /**
         * Creates a globalHeartPing message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.globalHeartPing
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.globalHeartPing} globalHeartPing
         */
        globalHeartPing.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.globalHeartPing)
                return object;
            var message = new $root.protoCmd.globalHeartPing();
            if (object.sign != null)
                if ($util.Long)
                    (message.sign = $util.Long.fromValue(object.sign)).unsigned = true;
                else if (typeof object.sign === "string")
                    message.sign = parseInt(object.sign, 10);
                else if (typeof object.sign === "number")
                    message.sign = object.sign;
                else if (typeof object.sign === "object")
                    message.sign = new $util.LongBits(object.sign.low >>> 0, object.sign.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a globalHeartPing message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.globalHeartPing
         * @static
         * @param {protoCmd.globalHeartPing} message globalHeartPing
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        globalHeartPing.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.sign = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.sign = options.longs === String ? "0" : 0;
            if (message.sign != null && message.hasOwnProperty("sign"))
                if (typeof message.sign === "number")
                    object.sign = options.longs === String ? String(message.sign) : message.sign;
                else
                    object.sign = options.longs === String ? $util.Long.prototype.toString.call(message.sign) : options.longs === Number ? new $util.LongBits(message.sign.low >>> 0, message.sign.high >>> 0).toNumber(true) : message.sign;
            return object;
        };

        /**
         * Converts this globalHeartPing to JSON.
         * @function toJSON
         * @memberof protoCmd.globalHeartPing
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        globalHeartPing.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return globalHeartPing;
    })();

    protoCmd.getReardHitReq = (function() {

        /**
         * Properties of a getReardHitReq.
         * @memberof protoCmd
         * @interface IgetReardHitReq
         * @property {number|Long|null} [coin] getReardHitReq coin
         * @property {number|Long|null} [guanka] getReardHitReq guanka
         */

        /**
         * Constructs a new getReardHitReq.
         * @memberof protoCmd
         * @classdesc Represents a getReardHitReq.
         * @implements IgetReardHitReq
         * @constructor
         * @param {protoCmd.IgetReardHitReq=} [properties] Properties to set
         */
        function getReardHitReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * getReardHitReq coin.
         * @member {number|Long} coin
         * @memberof protoCmd.getReardHitReq
         * @instance
         */
        getReardHitReq.prototype.coin = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * getReardHitReq guanka.
         * @member {number|Long} guanka
         * @memberof protoCmd.getReardHitReq
         * @instance
         */
        getReardHitReq.prototype.guanka = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new getReardHitReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.getReardHitReq
         * @static
         * @param {protoCmd.IgetReardHitReq=} [properties] Properties to set
         * @returns {protoCmd.getReardHitReq} getReardHitReq instance
         */
        getReardHitReq.create = function create(properties) {
            return new getReardHitReq(properties);
        };

        /**
         * Encodes the specified getReardHitReq message. Does not implicitly {@link protoCmd.getReardHitReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.getReardHitReq
         * @static
         * @param {protoCmd.IgetReardHitReq} message getReardHitReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getReardHitReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.coin != null && Object.hasOwnProperty.call(message, "coin"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.coin);
            if (message.guanka != null && Object.hasOwnProperty.call(message, "guanka"))
                writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.guanka);
            return writer;
        };

        /**
         * Encodes the specified getReardHitReq message, length delimited. Does not implicitly {@link protoCmd.getReardHitReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.getReardHitReq
         * @static
         * @param {protoCmd.IgetReardHitReq} message getReardHitReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getReardHitReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a getReardHitReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.getReardHitReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.getReardHitReq} getReardHitReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getReardHitReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.getReardHitReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.coin = reader.uint64();
                    break;
                case 2:
                    message.guanka = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a getReardHitReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.getReardHitReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.getReardHitReq} getReardHitReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getReardHitReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a getReardHitReq message.
         * @function verify
         * @memberof protoCmd.getReardHitReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        getReardHitReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.coin != null && message.hasOwnProperty("coin"))
                if (!$util.isInteger(message.coin) && !(message.coin && $util.isInteger(message.coin.low) && $util.isInteger(message.coin.high)))
                    return "coin: integer|Long expected";
            if (message.guanka != null && message.hasOwnProperty("guanka"))
                if (!$util.isInteger(message.guanka) && !(message.guanka && $util.isInteger(message.guanka.low) && $util.isInteger(message.guanka.high)))
                    return "guanka: integer|Long expected";
            return null;
        };

        /**
         * Creates a getReardHitReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.getReardHitReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.getReardHitReq} getReardHitReq
         */
        getReardHitReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.getReardHitReq)
                return object;
            var message = new $root.protoCmd.getReardHitReq();
            if (object.coin != null)
                if ($util.Long)
                    (message.coin = $util.Long.fromValue(object.coin)).unsigned = true;
                else if (typeof object.coin === "string")
                    message.coin = parseInt(object.coin, 10);
                else if (typeof object.coin === "number")
                    message.coin = object.coin;
                else if (typeof object.coin === "object")
                    message.coin = new $util.LongBits(object.coin.low >>> 0, object.coin.high >>> 0).toNumber(true);
            if (object.guanka != null)
                if ($util.Long)
                    (message.guanka = $util.Long.fromValue(object.guanka)).unsigned = true;
                else if (typeof object.guanka === "string")
                    message.guanka = parseInt(object.guanka, 10);
                else if (typeof object.guanka === "number")
                    message.guanka = object.guanka;
                else if (typeof object.guanka === "object")
                    message.guanka = new $util.LongBits(object.guanka.low >>> 0, object.guanka.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a getReardHitReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.getReardHitReq
         * @static
         * @param {protoCmd.getReardHitReq} message getReardHitReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        getReardHitReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.coin = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.coin = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.guanka = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.guanka = options.longs === String ? "0" : 0;
            }
            if (message.coin != null && message.hasOwnProperty("coin"))
                if (typeof message.coin === "number")
                    object.coin = options.longs === String ? String(message.coin) : message.coin;
                else
                    object.coin = options.longs === String ? $util.Long.prototype.toString.call(message.coin) : options.longs === Number ? new $util.LongBits(message.coin.low >>> 0, message.coin.high >>> 0).toNumber(true) : message.coin;
            if (message.guanka != null && message.hasOwnProperty("guanka"))
                if (typeof message.guanka === "number")
                    object.guanka = options.longs === String ? String(message.guanka) : message.guanka;
                else
                    object.guanka = options.longs === String ? $util.Long.prototype.toString.call(message.guanka) : options.longs === Number ? new $util.LongBits(message.guanka.low >>> 0, message.guanka.high >>> 0).toNumber(true) : message.guanka;
            return object;
        };

        /**
         * Converts this getReardHitReq to JSON.
         * @function toJSON
         * @memberof protoCmd.getReardHitReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        getReardHitReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return getReardHitReq;
    })();

    protoCmd.getReardHitRes = (function() {

        /**
         * Properties of a getReardHitRes.
         * @memberof protoCmd
         * @interface IgetReardHitRes
         * @property {number|Long|null} [coin] getReardHitRes coin
         * @property {number|Long|null} [guanka] getReardHitRes guanka
         */

        /**
         * Constructs a new getReardHitRes.
         * @memberof protoCmd
         * @classdesc Represents a getReardHitRes.
         * @implements IgetReardHitRes
         * @constructor
         * @param {protoCmd.IgetReardHitRes=} [properties] Properties to set
         */
        function getReardHitRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * getReardHitRes coin.
         * @member {number|Long} coin
         * @memberof protoCmd.getReardHitRes
         * @instance
         */
        getReardHitRes.prototype.coin = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * getReardHitRes guanka.
         * @member {number|Long} guanka
         * @memberof protoCmd.getReardHitRes
         * @instance
         */
        getReardHitRes.prototype.guanka = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new getReardHitRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.getReardHitRes
         * @static
         * @param {protoCmd.IgetReardHitRes=} [properties] Properties to set
         * @returns {protoCmd.getReardHitRes} getReardHitRes instance
         */
        getReardHitRes.create = function create(properties) {
            return new getReardHitRes(properties);
        };

        /**
         * Encodes the specified getReardHitRes message. Does not implicitly {@link protoCmd.getReardHitRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.getReardHitRes
         * @static
         * @param {protoCmd.IgetReardHitRes} message getReardHitRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getReardHitRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.coin != null && Object.hasOwnProperty.call(message, "coin"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.coin);
            if (message.guanka != null && Object.hasOwnProperty.call(message, "guanka"))
                writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.guanka);
            return writer;
        };

        /**
         * Encodes the specified getReardHitRes message, length delimited. Does not implicitly {@link protoCmd.getReardHitRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.getReardHitRes
         * @static
         * @param {protoCmd.IgetReardHitRes} message getReardHitRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getReardHitRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a getReardHitRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.getReardHitRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.getReardHitRes} getReardHitRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getReardHitRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.getReardHitRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.coin = reader.uint64();
                    break;
                case 2:
                    message.guanka = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a getReardHitRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.getReardHitRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.getReardHitRes} getReardHitRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getReardHitRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a getReardHitRes message.
         * @function verify
         * @memberof protoCmd.getReardHitRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        getReardHitRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.coin != null && message.hasOwnProperty("coin"))
                if (!$util.isInteger(message.coin) && !(message.coin && $util.isInteger(message.coin.low) && $util.isInteger(message.coin.high)))
                    return "coin: integer|Long expected";
            if (message.guanka != null && message.hasOwnProperty("guanka"))
                if (!$util.isInteger(message.guanka) && !(message.guanka && $util.isInteger(message.guanka.low) && $util.isInteger(message.guanka.high)))
                    return "guanka: integer|Long expected";
            return null;
        };

        /**
         * Creates a getReardHitRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.getReardHitRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.getReardHitRes} getReardHitRes
         */
        getReardHitRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.getReardHitRes)
                return object;
            var message = new $root.protoCmd.getReardHitRes();
            if (object.coin != null)
                if ($util.Long)
                    (message.coin = $util.Long.fromValue(object.coin)).unsigned = true;
                else if (typeof object.coin === "string")
                    message.coin = parseInt(object.coin, 10);
                else if (typeof object.coin === "number")
                    message.coin = object.coin;
                else if (typeof object.coin === "object")
                    message.coin = new $util.LongBits(object.coin.low >>> 0, object.coin.high >>> 0).toNumber(true);
            if (object.guanka != null)
                if ($util.Long)
                    (message.guanka = $util.Long.fromValue(object.guanka)).unsigned = true;
                else if (typeof object.guanka === "string")
                    message.guanka = parseInt(object.guanka, 10);
                else if (typeof object.guanka === "number")
                    message.guanka = object.guanka;
                else if (typeof object.guanka === "object")
                    message.guanka = new $util.LongBits(object.guanka.low >>> 0, object.guanka.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a getReardHitRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.getReardHitRes
         * @static
         * @param {protoCmd.getReardHitRes} message getReardHitRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        getReardHitRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.coin = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.coin = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.guanka = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.guanka = options.longs === String ? "0" : 0;
            }
            if (message.coin != null && message.hasOwnProperty("coin"))
                if (typeof message.coin === "number")
                    object.coin = options.longs === String ? String(message.coin) : message.coin;
                else
                    object.coin = options.longs === String ? $util.Long.prototype.toString.call(message.coin) : options.longs === Number ? new $util.LongBits(message.coin.low >>> 0, message.coin.high >>> 0).toNumber(true) : message.coin;
            if (message.guanka != null && message.hasOwnProperty("guanka"))
                if (typeof message.guanka === "number")
                    object.guanka = options.longs === String ? String(message.guanka) : message.guanka;
                else
                    object.guanka = options.longs === String ? $util.Long.prototype.toString.call(message.guanka) : options.longs === Number ? new $util.LongBits(message.guanka.low >>> 0, message.guanka.high >>> 0).toNumber(true) : message.guanka;
            return object;
        };

        /**
         * Converts this getReardHitRes to JSON.
         * @function toJSON
         * @memberof protoCmd.getReardHitRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        getReardHitRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return getReardHitRes;
    })();

    protoCmd.getCutPowerReq = (function() {

        /**
         * Properties of a getCutPowerReq.
         * @memberof protoCmd
         * @interface IgetCutPowerReq
         * @property {number|Long|null} [power] getCutPowerReq power
         */

        /**
         * Constructs a new getCutPowerReq.
         * @memberof protoCmd
         * @classdesc Represents a getCutPowerReq.
         * @implements IgetCutPowerReq
         * @constructor
         * @param {protoCmd.IgetCutPowerReq=} [properties] Properties to set
         */
        function getCutPowerReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * getCutPowerReq power.
         * @member {number|Long} power
         * @memberof protoCmd.getCutPowerReq
         * @instance
         */
        getCutPowerReq.prototype.power = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new getCutPowerReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.getCutPowerReq
         * @static
         * @param {protoCmd.IgetCutPowerReq=} [properties] Properties to set
         * @returns {protoCmd.getCutPowerReq} getCutPowerReq instance
         */
        getCutPowerReq.create = function create(properties) {
            return new getCutPowerReq(properties);
        };

        /**
         * Encodes the specified getCutPowerReq message. Does not implicitly {@link protoCmd.getCutPowerReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.getCutPowerReq
         * @static
         * @param {protoCmd.IgetCutPowerReq} message getCutPowerReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getCutPowerReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.power != null && Object.hasOwnProperty.call(message, "power"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.power);
            return writer;
        };

        /**
         * Encodes the specified getCutPowerReq message, length delimited. Does not implicitly {@link protoCmd.getCutPowerReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.getCutPowerReq
         * @static
         * @param {protoCmd.IgetCutPowerReq} message getCutPowerReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getCutPowerReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a getCutPowerReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.getCutPowerReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.getCutPowerReq} getCutPowerReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getCutPowerReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.getCutPowerReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.power = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a getCutPowerReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.getCutPowerReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.getCutPowerReq} getCutPowerReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getCutPowerReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a getCutPowerReq message.
         * @function verify
         * @memberof protoCmd.getCutPowerReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        getCutPowerReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.power != null && message.hasOwnProperty("power"))
                if (!$util.isInteger(message.power) && !(message.power && $util.isInteger(message.power.low) && $util.isInteger(message.power.high)))
                    return "power: integer|Long expected";
            return null;
        };

        /**
         * Creates a getCutPowerReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.getCutPowerReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.getCutPowerReq} getCutPowerReq
         */
        getCutPowerReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.getCutPowerReq)
                return object;
            var message = new $root.protoCmd.getCutPowerReq();
            if (object.power != null)
                if ($util.Long)
                    (message.power = $util.Long.fromValue(object.power)).unsigned = true;
                else if (typeof object.power === "string")
                    message.power = parseInt(object.power, 10);
                else if (typeof object.power === "number")
                    message.power = object.power;
                else if (typeof object.power === "object")
                    message.power = new $util.LongBits(object.power.low >>> 0, object.power.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a getCutPowerReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.getCutPowerReq
         * @static
         * @param {protoCmd.getCutPowerReq} message getCutPowerReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        getCutPowerReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.power = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.power = options.longs === String ? "0" : 0;
            if (message.power != null && message.hasOwnProperty("power"))
                if (typeof message.power === "number")
                    object.power = options.longs === String ? String(message.power) : message.power;
                else
                    object.power = options.longs === String ? $util.Long.prototype.toString.call(message.power) : options.longs === Number ? new $util.LongBits(message.power.low >>> 0, message.power.high >>> 0).toNumber(true) : message.power;
            return object;
        };

        /**
         * Converts this getCutPowerReq to JSON.
         * @function toJSON
         * @memberof protoCmd.getCutPowerReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        getCutPowerReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return getCutPowerReq;
    })();

    protoCmd.getAddPowerRes = (function() {

        /**
         * Properties of a getAddPowerRes.
         * @memberof protoCmd
         * @interface IgetAddPowerRes
         * @property {number|Long|null} [power] getAddPowerRes power
         */

        /**
         * Constructs a new getAddPowerRes.
         * @memberof protoCmd
         * @classdesc Represents a getAddPowerRes.
         * @implements IgetAddPowerRes
         * @constructor
         * @param {protoCmd.IgetAddPowerRes=} [properties] Properties to set
         */
        function getAddPowerRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * getAddPowerRes power.
         * @member {number|Long} power
         * @memberof protoCmd.getAddPowerRes
         * @instance
         */
        getAddPowerRes.prototype.power = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new getAddPowerRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.getAddPowerRes
         * @static
         * @param {protoCmd.IgetAddPowerRes=} [properties] Properties to set
         * @returns {protoCmd.getAddPowerRes} getAddPowerRes instance
         */
        getAddPowerRes.create = function create(properties) {
            return new getAddPowerRes(properties);
        };

        /**
         * Encodes the specified getAddPowerRes message. Does not implicitly {@link protoCmd.getAddPowerRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.getAddPowerRes
         * @static
         * @param {protoCmd.IgetAddPowerRes} message getAddPowerRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getAddPowerRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.power != null && Object.hasOwnProperty.call(message, "power"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.power);
            return writer;
        };

        /**
         * Encodes the specified getAddPowerRes message, length delimited. Does not implicitly {@link protoCmd.getAddPowerRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.getAddPowerRes
         * @static
         * @param {protoCmd.IgetAddPowerRes} message getAddPowerRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        getAddPowerRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a getAddPowerRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.getAddPowerRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.getAddPowerRes} getAddPowerRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getAddPowerRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.getAddPowerRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.power = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a getAddPowerRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.getAddPowerRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.getAddPowerRes} getAddPowerRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        getAddPowerRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a getAddPowerRes message.
         * @function verify
         * @memberof protoCmd.getAddPowerRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        getAddPowerRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.power != null && message.hasOwnProperty("power"))
                if (!$util.isInteger(message.power) && !(message.power && $util.isInteger(message.power.low) && $util.isInteger(message.power.high)))
                    return "power: integer|Long expected";
            return null;
        };

        /**
         * Creates a getAddPowerRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.getAddPowerRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.getAddPowerRes} getAddPowerRes
         */
        getAddPowerRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.getAddPowerRes)
                return object;
            var message = new $root.protoCmd.getAddPowerRes();
            if (object.power != null)
                if ($util.Long)
                    (message.power = $util.Long.fromValue(object.power)).unsigned = true;
                else if (typeof object.power === "string")
                    message.power = parseInt(object.power, 10);
                else if (typeof object.power === "number")
                    message.power = object.power;
                else if (typeof object.power === "object")
                    message.power = new $util.LongBits(object.power.low >>> 0, object.power.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a getAddPowerRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.getAddPowerRes
         * @static
         * @param {protoCmd.getAddPowerRes} message getAddPowerRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        getAddPowerRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.power = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.power = options.longs === String ? "0" : 0;
            if (message.power != null && message.hasOwnProperty("power"))
                if (typeof message.power === "number")
                    object.power = options.longs === String ? String(message.power) : message.power;
                else
                    object.power = options.longs === String ? $util.Long.prototype.toString.call(message.power) : options.longs === Number ? new $util.LongBits(message.power.low >>> 0, message.power.high >>> 0).toNumber(true) : message.power;
            return object;
        };

        /**
         * Converts this getAddPowerRes to JSON.
         * @function toJSON
         * @memberof protoCmd.getAddPowerRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        getAddPowerRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return getAddPowerRes;
    })();

    protoCmd.sendGmReq = (function() {

        /**
         * Properties of a sendGmReq.
         * @memberof protoCmd
         * @interface IsendGmReq
         * @property {string|null} [gm] sendGmReq gm
         */

        /**
         * Constructs a new sendGmReq.
         * @memberof protoCmd
         * @classdesc Represents a sendGmReq.
         * @implements IsendGmReq
         * @constructor
         * @param {protoCmd.IsendGmReq=} [properties] Properties to set
         */
        function sendGmReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * sendGmReq gm.
         * @member {string} gm
         * @memberof protoCmd.sendGmReq
         * @instance
         */
        sendGmReq.prototype.gm = "";

        /**
         * Creates a new sendGmReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.sendGmReq
         * @static
         * @param {protoCmd.IsendGmReq=} [properties] Properties to set
         * @returns {protoCmd.sendGmReq} sendGmReq instance
         */
        sendGmReq.create = function create(properties) {
            return new sendGmReq(properties);
        };

        /**
         * Encodes the specified sendGmReq message. Does not implicitly {@link protoCmd.sendGmReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.sendGmReq
         * @static
         * @param {protoCmd.IsendGmReq} message sendGmReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        sendGmReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.gm != null && Object.hasOwnProperty.call(message, "gm"))
                writer.uint32(/* id 1, wireType 2 =*/10).string(message.gm);
            return writer;
        };

        /**
         * Encodes the specified sendGmReq message, length delimited. Does not implicitly {@link protoCmd.sendGmReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.sendGmReq
         * @static
         * @param {protoCmd.IsendGmReq} message sendGmReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        sendGmReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a sendGmReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.sendGmReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.sendGmReq} sendGmReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        sendGmReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.sendGmReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.gm = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a sendGmReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.sendGmReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.sendGmReq} sendGmReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        sendGmReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a sendGmReq message.
         * @function verify
         * @memberof protoCmd.sendGmReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        sendGmReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.gm != null && message.hasOwnProperty("gm"))
                if (!$util.isString(message.gm))
                    return "gm: string expected";
            return null;
        };

        /**
         * Creates a sendGmReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.sendGmReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.sendGmReq} sendGmReq
         */
        sendGmReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.sendGmReq)
                return object;
            var message = new $root.protoCmd.sendGmReq();
            if (object.gm != null)
                message.gm = String(object.gm);
            return message;
        };

        /**
         * Creates a plain object from a sendGmReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.sendGmReq
         * @static
         * @param {protoCmd.sendGmReq} message sendGmReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        sendGmReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                object.gm = "";
            if (message.gm != null && message.hasOwnProperty("gm"))
                object.gm = message.gm;
            return object;
        };

        /**
         * Converts this sendGmReq to JSON.
         * @function toJSON
         * @memberof protoCmd.sendGmReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        sendGmReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return sendGmReq;
    })();

    protoCmd.mailSyn = (function() {

        /**
         * Properties of a mailSyn.
         * @memberof protoCmd
         * @interface ImailSyn
         * @property {Array.<protoCmd.ImailRes>|null} [mailList] mailSyn mailList
         */

        /**
         * Constructs a new mailSyn.
         * @memberof protoCmd
         * @classdesc Represents a mailSyn.
         * @implements ImailSyn
         * @constructor
         * @param {protoCmd.ImailSyn=} [properties] Properties to set
         */
        function mailSyn(properties) {
            this.mailList = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mailSyn mailList.
         * @member {Array.<protoCmd.ImailRes>} mailList
         * @memberof protoCmd.mailSyn
         * @instance
         */
        mailSyn.prototype.mailList = $util.emptyArray;

        /**
         * Creates a new mailSyn instance using the specified properties.
         * @function create
         * @memberof protoCmd.mailSyn
         * @static
         * @param {protoCmd.ImailSyn=} [properties] Properties to set
         * @returns {protoCmd.mailSyn} mailSyn instance
         */
        mailSyn.create = function create(properties) {
            return new mailSyn(properties);
        };

        /**
         * Encodes the specified mailSyn message. Does not implicitly {@link protoCmd.mailSyn.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.mailSyn
         * @static
         * @param {protoCmd.ImailSyn} message mailSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailSyn.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.mailList != null && message.mailList.length)
                for (var i = 0; i < message.mailList.length; ++i)
                    $root.protoCmd.mailRes.encode(message.mailList[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified mailSyn message, length delimited. Does not implicitly {@link protoCmd.mailSyn.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.mailSyn
         * @static
         * @param {protoCmd.ImailSyn} message mailSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailSyn.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mailSyn message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.mailSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.mailSyn} mailSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailSyn.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.mailSyn();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    if (!(message.mailList && message.mailList.length))
                        message.mailList = [];
                    message.mailList.push($root.protoCmd.mailRes.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a mailSyn message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.mailSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.mailSyn} mailSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailSyn.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mailSyn message.
         * @function verify
         * @memberof protoCmd.mailSyn
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mailSyn.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.mailList != null && message.hasOwnProperty("mailList")) {
                if (!Array.isArray(message.mailList))
                    return "mailList: array expected";
                for (var i = 0; i < message.mailList.length; ++i) {
                    var error = $root.protoCmd.mailRes.verify(message.mailList[i]);
                    if (error)
                        return "mailList." + error;
                }
            }
            return null;
        };

        /**
         * Creates a mailSyn message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.mailSyn
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.mailSyn} mailSyn
         */
        mailSyn.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.mailSyn)
                return object;
            var message = new $root.protoCmd.mailSyn();
            if (object.mailList) {
                if (!Array.isArray(object.mailList))
                    throw TypeError(".protoCmd.mailSyn.mailList: array expected");
                message.mailList = [];
                for (var i = 0; i < object.mailList.length; ++i) {
                    if (typeof object.mailList[i] !== "object")
                        throw TypeError(".protoCmd.mailSyn.mailList: object expected");
                    message.mailList[i] = $root.protoCmd.mailRes.fromObject(object.mailList[i]);
                }
            }
            return message;
        };

        /**
         * Creates a plain object from a mailSyn message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.mailSyn
         * @static
         * @param {protoCmd.mailSyn} message mailSyn
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        mailSyn.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.arrays || options.defaults)
                object.mailList = [];
            if (message.mailList && message.mailList.length) {
                object.mailList = [];
                for (var j = 0; j < message.mailList.length; ++j)
                    object.mailList[j] = $root.protoCmd.mailRes.toObject(message.mailList[j], options);
            }
            return object;
        };

        /**
         * Converts this mailSyn to JSON.
         * @function toJSON
         * @memberof protoCmd.mailSyn
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        mailSyn.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return mailSyn;
    })();

    protoCmd.awarddict = (function() {

        /**
         * Properties of an awarddict.
         * @memberof protoCmd
         * @interface Iawarddict
         * @property {number|null} [type] awarddict type
         * @property {number|null} [cid] awarddict cid
         * @property {number|null} [num] awarddict num
         */

        /**
         * Constructs a new awarddict.
         * @memberof protoCmd
         * @classdesc Represents an awarddict.
         * @implements Iawarddict
         * @constructor
         * @param {protoCmd.Iawarddict=} [properties] Properties to set
         */
        function awarddict(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * awarddict type.
         * @member {number} type
         * @memberof protoCmd.awarddict
         * @instance
         */
        awarddict.prototype.type = 0;

        /**
         * awarddict cid.
         * @member {number} cid
         * @memberof protoCmd.awarddict
         * @instance
         */
        awarddict.prototype.cid = 0;

        /**
         * awarddict num.
         * @member {number} num
         * @memberof protoCmd.awarddict
         * @instance
         */
        awarddict.prototype.num = 0;

        /**
         * Creates a new awarddict instance using the specified properties.
         * @function create
         * @memberof protoCmd.awarddict
         * @static
         * @param {protoCmd.Iawarddict=} [properties] Properties to set
         * @returns {protoCmd.awarddict} awarddict instance
         */
        awarddict.create = function create(properties) {
            return new awarddict(properties);
        };

        /**
         * Encodes the specified awarddict message. Does not implicitly {@link protoCmd.awarddict.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.awarddict
         * @static
         * @param {protoCmd.Iawarddict} message awarddict message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        awarddict.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.type);
            if (message.cid != null && Object.hasOwnProperty.call(message, "cid"))
                writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.cid);
            if (message.num != null && Object.hasOwnProperty.call(message, "num"))
                writer.uint32(/* id 3, wireType 0 =*/24).uint32(message.num);
            return writer;
        };

        /**
         * Encodes the specified awarddict message, length delimited. Does not implicitly {@link protoCmd.awarddict.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.awarddict
         * @static
         * @param {protoCmd.Iawarddict} message awarddict message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        awarddict.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an awarddict message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.awarddict
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.awarddict} awarddict
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        awarddict.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.awarddict();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.type = reader.uint32();
                    break;
                case 2:
                    message.cid = reader.uint32();
                    break;
                case 3:
                    message.num = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes an awarddict message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.awarddict
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.awarddict} awarddict
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        awarddict.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an awarddict message.
         * @function verify
         * @memberof protoCmd.awarddict
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        awarddict.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.type != null && message.hasOwnProperty("type"))
                if (!$util.isInteger(message.type))
                    return "type: integer expected";
            if (message.cid != null && message.hasOwnProperty("cid"))
                if (!$util.isInteger(message.cid))
                    return "cid: integer expected";
            if (message.num != null && message.hasOwnProperty("num"))
                if (!$util.isInteger(message.num))
                    return "num: integer expected";
            return null;
        };

        /**
         * Creates an awarddict message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.awarddict
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.awarddict} awarddict
         */
        awarddict.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.awarddict)
                return object;
            var message = new $root.protoCmd.awarddict();
            if (object.type != null)
                message.type = object.type >>> 0;
            if (object.cid != null)
                message.cid = object.cid >>> 0;
            if (object.num != null)
                message.num = object.num >>> 0;
            return message;
        };

        /**
         * Creates a plain object from an awarddict message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.awarddict
         * @static
         * @param {protoCmd.awarddict} message awarddict
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        awarddict.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                object.type = 0;
                object.cid = 0;
                object.num = 0;
            }
            if (message.type != null && message.hasOwnProperty("type"))
                object.type = message.type;
            if (message.cid != null && message.hasOwnProperty("cid"))
                object.cid = message.cid;
            if (message.num != null && message.hasOwnProperty("num"))
                object.num = message.num;
            return object;
        };

        /**
         * Converts this awarddict to JSON.
         * @function toJSON
         * @memberof protoCmd.awarddict
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        awarddict.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return awarddict;
    })();

    protoCmd.mailRes = (function() {

        /**
         * Properties of a mailRes.
         * @memberof protoCmd
         * @interface ImailRes
         * @property {number|Long|null} [uid] mailRes uid
         * @property {string|null} [head] mailRes head
         * @property {string|null} [context] mailRes context
         * @property {number|Long|null} [exp] mailRes exp
         * @property {number|Long|null} [coin] mailRes coin
         * @property {number|Long|null} [diamond] mailRes diamond
         * @property {Array.<protoCmd.Iawarddict>|null} [awardlist] mailRes awardlist
         * @property {number|Long|null} [sendtime] mailRes sendtime
         * @property {boolean|null} [readstatus] mailRes readstatus
         * @property {boolean|null} [awardstatus] mailRes awardstatus
         */

        /**
         * Constructs a new mailRes.
         * @memberof protoCmd
         * @classdesc Represents a mailRes.
         * @implements ImailRes
         * @constructor
         * @param {protoCmd.ImailRes=} [properties] Properties to set
         */
        function mailRes(properties) {
            this.awardlist = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mailRes uid.
         * @member {number|Long} uid
         * @memberof protoCmd.mailRes
         * @instance
         */
        mailRes.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * mailRes head.
         * @member {string} head
         * @memberof protoCmd.mailRes
         * @instance
         */
        mailRes.prototype.head = "";

        /**
         * mailRes context.
         * @member {string} context
         * @memberof protoCmd.mailRes
         * @instance
         */
        mailRes.prototype.context = "";

        /**
         * mailRes exp.
         * @member {number|Long} exp
         * @memberof protoCmd.mailRes
         * @instance
         */
        mailRes.prototype.exp = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * mailRes coin.
         * @member {number|Long} coin
         * @memberof protoCmd.mailRes
         * @instance
         */
        mailRes.prototype.coin = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * mailRes diamond.
         * @member {number|Long} diamond
         * @memberof protoCmd.mailRes
         * @instance
         */
        mailRes.prototype.diamond = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * mailRes awardlist.
         * @member {Array.<protoCmd.Iawarddict>} awardlist
         * @memberof protoCmd.mailRes
         * @instance
         */
        mailRes.prototype.awardlist = $util.emptyArray;

        /**
         * mailRes sendtime.
         * @member {number|Long} sendtime
         * @memberof protoCmd.mailRes
         * @instance
         */
        mailRes.prototype.sendtime = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * mailRes readstatus.
         * @member {boolean} readstatus
         * @memberof protoCmd.mailRes
         * @instance
         */
        mailRes.prototype.readstatus = false;

        /**
         * mailRes awardstatus.
         * @member {boolean} awardstatus
         * @memberof protoCmd.mailRes
         * @instance
         */
        mailRes.prototype.awardstatus = false;

        /**
         * Creates a new mailRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.mailRes
         * @static
         * @param {protoCmd.ImailRes=} [properties] Properties to set
         * @returns {protoCmd.mailRes} mailRes instance
         */
        mailRes.create = function create(properties) {
            return new mailRes(properties);
        };

        /**
         * Encodes the specified mailRes message. Does not implicitly {@link protoCmd.mailRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.mailRes
         * @static
         * @param {protoCmd.ImailRes} message mailRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            if (message.head != null && Object.hasOwnProperty.call(message, "head"))
                writer.uint32(/* id 2, wireType 2 =*/18).string(message.head);
            if (message.context != null && Object.hasOwnProperty.call(message, "context"))
                writer.uint32(/* id 3, wireType 2 =*/26).string(message.context);
            if (message.exp != null && Object.hasOwnProperty.call(message, "exp"))
                writer.uint32(/* id 4, wireType 0 =*/32).uint64(message.exp);
            if (message.coin != null && Object.hasOwnProperty.call(message, "coin"))
                writer.uint32(/* id 5, wireType 0 =*/40).uint64(message.coin);
            if (message.diamond != null && Object.hasOwnProperty.call(message, "diamond"))
                writer.uint32(/* id 6, wireType 0 =*/48).uint64(message.diamond);
            if (message.awardlist != null && message.awardlist.length)
                for (var i = 0; i < message.awardlist.length; ++i)
                    $root.protoCmd.awarddict.encode(message.awardlist[i], writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
            if (message.sendtime != null && Object.hasOwnProperty.call(message, "sendtime"))
                writer.uint32(/* id 8, wireType 0 =*/64).uint64(message.sendtime);
            if (message.readstatus != null && Object.hasOwnProperty.call(message, "readstatus"))
                writer.uint32(/* id 9, wireType 0 =*/72).bool(message.readstatus);
            if (message.awardstatus != null && Object.hasOwnProperty.call(message, "awardstatus"))
                writer.uint32(/* id 10, wireType 0 =*/80).bool(message.awardstatus);
            return writer;
        };

        /**
         * Encodes the specified mailRes message, length delimited. Does not implicitly {@link protoCmd.mailRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.mailRes
         * @static
         * @param {protoCmd.ImailRes} message mailRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mailRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.mailRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.mailRes} mailRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.mailRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                case 2:
                    message.head = reader.string();
                    break;
                case 3:
                    message.context = reader.string();
                    break;
                case 4:
                    message.exp = reader.uint64();
                    break;
                case 5:
                    message.coin = reader.uint64();
                    break;
                case 6:
                    message.diamond = reader.uint64();
                    break;
                case 7:
                    if (!(message.awardlist && message.awardlist.length))
                        message.awardlist = [];
                    message.awardlist.push($root.protoCmd.awarddict.decode(reader, reader.uint32()));
                    break;
                case 8:
                    message.sendtime = reader.uint64();
                    break;
                case 9:
                    message.readstatus = reader.bool();
                    break;
                case 10:
                    message.awardstatus = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a mailRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.mailRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.mailRes} mailRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mailRes message.
         * @function verify
         * @memberof protoCmd.mailRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mailRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            if (message.head != null && message.hasOwnProperty("head"))
                if (!$util.isString(message.head))
                    return "head: string expected";
            if (message.context != null && message.hasOwnProperty("context"))
                if (!$util.isString(message.context))
                    return "context: string expected";
            if (message.exp != null && message.hasOwnProperty("exp"))
                if (!$util.isInteger(message.exp) && !(message.exp && $util.isInteger(message.exp.low) && $util.isInteger(message.exp.high)))
                    return "exp: integer|Long expected";
            if (message.coin != null && message.hasOwnProperty("coin"))
                if (!$util.isInteger(message.coin) && !(message.coin && $util.isInteger(message.coin.low) && $util.isInteger(message.coin.high)))
                    return "coin: integer|Long expected";
            if (message.diamond != null && message.hasOwnProperty("diamond"))
                if (!$util.isInteger(message.diamond) && !(message.diamond && $util.isInteger(message.diamond.low) && $util.isInteger(message.diamond.high)))
                    return "diamond: integer|Long expected";
            if (message.awardlist != null && message.hasOwnProperty("awardlist")) {
                if (!Array.isArray(message.awardlist))
                    return "awardlist: array expected";
                for (var i = 0; i < message.awardlist.length; ++i) {
                    var error = $root.protoCmd.awarddict.verify(message.awardlist[i]);
                    if (error)
                        return "awardlist." + error;
                }
            }
            if (message.sendtime != null && message.hasOwnProperty("sendtime"))
                if (!$util.isInteger(message.sendtime) && !(message.sendtime && $util.isInteger(message.sendtime.low) && $util.isInteger(message.sendtime.high)))
                    return "sendtime: integer|Long expected";
            if (message.readstatus != null && message.hasOwnProperty("readstatus"))
                if (typeof message.readstatus !== "boolean")
                    return "readstatus: boolean expected";
            if (message.awardstatus != null && message.hasOwnProperty("awardstatus"))
                if (typeof message.awardstatus !== "boolean")
                    return "awardstatus: boolean expected";
            return null;
        };

        /**
         * Creates a mailRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.mailRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.mailRes} mailRes
         */
        mailRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.mailRes)
                return object;
            var message = new $root.protoCmd.mailRes();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            if (object.head != null)
                message.head = String(object.head);
            if (object.context != null)
                message.context = String(object.context);
            if (object.exp != null)
                if ($util.Long)
                    (message.exp = $util.Long.fromValue(object.exp)).unsigned = true;
                else if (typeof object.exp === "string")
                    message.exp = parseInt(object.exp, 10);
                else if (typeof object.exp === "number")
                    message.exp = object.exp;
                else if (typeof object.exp === "object")
                    message.exp = new $util.LongBits(object.exp.low >>> 0, object.exp.high >>> 0).toNumber(true);
            if (object.coin != null)
                if ($util.Long)
                    (message.coin = $util.Long.fromValue(object.coin)).unsigned = true;
                else if (typeof object.coin === "string")
                    message.coin = parseInt(object.coin, 10);
                else if (typeof object.coin === "number")
                    message.coin = object.coin;
                else if (typeof object.coin === "object")
                    message.coin = new $util.LongBits(object.coin.low >>> 0, object.coin.high >>> 0).toNumber(true);
            if (object.diamond != null)
                if ($util.Long)
                    (message.diamond = $util.Long.fromValue(object.diamond)).unsigned = true;
                else if (typeof object.diamond === "string")
                    message.diamond = parseInt(object.diamond, 10);
                else if (typeof object.diamond === "number")
                    message.diamond = object.diamond;
                else if (typeof object.diamond === "object")
                    message.diamond = new $util.LongBits(object.diamond.low >>> 0, object.diamond.high >>> 0).toNumber(true);
            if (object.awardlist) {
                if (!Array.isArray(object.awardlist))
                    throw TypeError(".protoCmd.mailRes.awardlist: array expected");
                message.awardlist = [];
                for (var i = 0; i < object.awardlist.length; ++i) {
                    if (typeof object.awardlist[i] !== "object")
                        throw TypeError(".protoCmd.mailRes.awardlist: object expected");
                    message.awardlist[i] = $root.protoCmd.awarddict.fromObject(object.awardlist[i]);
                }
            }
            if (object.sendtime != null)
                if ($util.Long)
                    (message.sendtime = $util.Long.fromValue(object.sendtime)).unsigned = true;
                else if (typeof object.sendtime === "string")
                    message.sendtime = parseInt(object.sendtime, 10);
                else if (typeof object.sendtime === "number")
                    message.sendtime = object.sendtime;
                else if (typeof object.sendtime === "object")
                    message.sendtime = new $util.LongBits(object.sendtime.low >>> 0, object.sendtime.high >>> 0).toNumber(true);
            if (object.readstatus != null)
                message.readstatus = Boolean(object.readstatus);
            if (object.awardstatus != null)
                message.awardstatus = Boolean(object.awardstatus);
            return message;
        };

        /**
         * Creates a plain object from a mailRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.mailRes
         * @static
         * @param {protoCmd.mailRes} message mailRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        mailRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.arrays || options.defaults)
                object.awardlist = [];
            if (options.defaults) {
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
                object.head = "";
                object.context = "";
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.exp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.exp = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.coin = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.coin = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.diamond = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.diamond = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.sendtime = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.sendtime = options.longs === String ? "0" : 0;
                object.readstatus = false;
                object.awardstatus = false;
            }
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            if (message.head != null && message.hasOwnProperty("head"))
                object.head = message.head;
            if (message.context != null && message.hasOwnProperty("context"))
                object.context = message.context;
            if (message.exp != null && message.hasOwnProperty("exp"))
                if (typeof message.exp === "number")
                    object.exp = options.longs === String ? String(message.exp) : message.exp;
                else
                    object.exp = options.longs === String ? $util.Long.prototype.toString.call(message.exp) : options.longs === Number ? new $util.LongBits(message.exp.low >>> 0, message.exp.high >>> 0).toNumber(true) : message.exp;
            if (message.coin != null && message.hasOwnProperty("coin"))
                if (typeof message.coin === "number")
                    object.coin = options.longs === String ? String(message.coin) : message.coin;
                else
                    object.coin = options.longs === String ? $util.Long.prototype.toString.call(message.coin) : options.longs === Number ? new $util.LongBits(message.coin.low >>> 0, message.coin.high >>> 0).toNumber(true) : message.coin;
            if (message.diamond != null && message.hasOwnProperty("diamond"))
                if (typeof message.diamond === "number")
                    object.diamond = options.longs === String ? String(message.diamond) : message.diamond;
                else
                    object.diamond = options.longs === String ? $util.Long.prototype.toString.call(message.diamond) : options.longs === Number ? new $util.LongBits(message.diamond.low >>> 0, message.diamond.high >>> 0).toNumber(true) : message.diamond;
            if (message.awardlist && message.awardlist.length) {
                object.awardlist = [];
                for (var j = 0; j < message.awardlist.length; ++j)
                    object.awardlist[j] = $root.protoCmd.awarddict.toObject(message.awardlist[j], options);
            }
            if (message.sendtime != null && message.hasOwnProperty("sendtime"))
                if (typeof message.sendtime === "number")
                    object.sendtime = options.longs === String ? String(message.sendtime) : message.sendtime;
                else
                    object.sendtime = options.longs === String ? $util.Long.prototype.toString.call(message.sendtime) : options.longs === Number ? new $util.LongBits(message.sendtime.low >>> 0, message.sendtime.high >>> 0).toNumber(true) : message.sendtime;
            if (message.readstatus != null && message.hasOwnProperty("readstatus"))
                object.readstatus = message.readstatus;
            if (message.awardstatus != null && message.hasOwnProperty("awardstatus"))
                object.awardstatus = message.awardstatus;
            return object;
        };

        /**
         * Converts this mailRes to JSON.
         * @function toJSON
         * @memberof protoCmd.mailRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        mailRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return mailRes;
    })();

    protoCmd.mailSingleReq = (function() {

        /**
         * Properties of a mailSingleReq.
         * @memberof protoCmd
         * @interface ImailSingleReq
         * @property {number|Long|null} [uid] mailSingleReq uid
         */

        /**
         * Constructs a new mailSingleReq.
         * @memberof protoCmd
         * @classdesc Represents a mailSingleReq.
         * @implements ImailSingleReq
         * @constructor
         * @param {protoCmd.ImailSingleReq=} [properties] Properties to set
         */
        function mailSingleReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mailSingleReq uid.
         * @member {number|Long} uid
         * @memberof protoCmd.mailSingleReq
         * @instance
         */
        mailSingleReq.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new mailSingleReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.mailSingleReq
         * @static
         * @param {protoCmd.ImailSingleReq=} [properties] Properties to set
         * @returns {protoCmd.mailSingleReq} mailSingleReq instance
         */
        mailSingleReq.create = function create(properties) {
            return new mailSingleReq(properties);
        };

        /**
         * Encodes the specified mailSingleReq message. Does not implicitly {@link protoCmd.mailSingleReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.mailSingleReq
         * @static
         * @param {protoCmd.ImailSingleReq} message mailSingleReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailSingleReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            return writer;
        };

        /**
         * Encodes the specified mailSingleReq message, length delimited. Does not implicitly {@link protoCmd.mailSingleReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.mailSingleReq
         * @static
         * @param {protoCmd.ImailSingleReq} message mailSingleReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailSingleReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mailSingleReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.mailSingleReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.mailSingleReq} mailSingleReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailSingleReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.mailSingleReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a mailSingleReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.mailSingleReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.mailSingleReq} mailSingleReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailSingleReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mailSingleReq message.
         * @function verify
         * @memberof protoCmd.mailSingleReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mailSingleReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            return null;
        };

        /**
         * Creates a mailSingleReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.mailSingleReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.mailSingleReq} mailSingleReq
         */
        mailSingleReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.mailSingleReq)
                return object;
            var message = new $root.protoCmd.mailSingleReq();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a mailSingleReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.mailSingleReq
         * @static
         * @param {protoCmd.mailSingleReq} message mailSingleReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        mailSingleReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            return object;
        };

        /**
         * Converts this mailSingleReq to JSON.
         * @function toJSON
         * @memberof protoCmd.mailSingleReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        mailSingleReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return mailSingleReq;
    })();

    protoCmd.mailSingleRes = (function() {

        /**
         * Properties of a mailSingleRes.
         * @memberof protoCmd
         * @interface ImailSingleRes
         * @property {number|Long|null} [uid] mailSingleRes uid
         */

        /**
         * Constructs a new mailSingleRes.
         * @memberof protoCmd
         * @classdesc Represents a mailSingleRes.
         * @implements ImailSingleRes
         * @constructor
         * @param {protoCmd.ImailSingleRes=} [properties] Properties to set
         */
        function mailSingleRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mailSingleRes uid.
         * @member {number|Long} uid
         * @memberof protoCmd.mailSingleRes
         * @instance
         */
        mailSingleRes.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new mailSingleRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.mailSingleRes
         * @static
         * @param {protoCmd.ImailSingleRes=} [properties] Properties to set
         * @returns {protoCmd.mailSingleRes} mailSingleRes instance
         */
        mailSingleRes.create = function create(properties) {
            return new mailSingleRes(properties);
        };

        /**
         * Encodes the specified mailSingleRes message. Does not implicitly {@link protoCmd.mailSingleRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.mailSingleRes
         * @static
         * @param {protoCmd.ImailSingleRes} message mailSingleRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailSingleRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            return writer;
        };

        /**
         * Encodes the specified mailSingleRes message, length delimited. Does not implicitly {@link protoCmd.mailSingleRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.mailSingleRes
         * @static
         * @param {protoCmd.ImailSingleRes} message mailSingleRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailSingleRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mailSingleRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.mailSingleRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.mailSingleRes} mailSingleRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailSingleRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.mailSingleRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a mailSingleRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.mailSingleRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.mailSingleRes} mailSingleRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailSingleRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mailSingleRes message.
         * @function verify
         * @memberof protoCmd.mailSingleRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mailSingleRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            return null;
        };

        /**
         * Creates a mailSingleRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.mailSingleRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.mailSingleRes} mailSingleRes
         */
        mailSingleRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.mailSingleRes)
                return object;
            var message = new $root.protoCmd.mailSingleRes();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a mailSingleRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.mailSingleRes
         * @static
         * @param {protoCmd.mailSingleRes} message mailSingleRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        mailSingleRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            return object;
        };

        /**
         * Converts this mailSingleRes to JSON.
         * @function toJSON
         * @memberof protoCmd.mailSingleRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        mailSingleRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return mailSingleRes;
    })();

    protoCmd.mailRewardReq = (function() {

        /**
         * Properties of a mailRewardReq.
         * @memberof protoCmd
         * @interface ImailRewardReq
         * @property {number|Long|null} [uid] mailRewardReq uid
         */

        /**
         * Constructs a new mailRewardReq.
         * @memberof protoCmd
         * @classdesc Represents a mailRewardReq.
         * @implements ImailRewardReq
         * @constructor
         * @param {protoCmd.ImailRewardReq=} [properties] Properties to set
         */
        function mailRewardReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mailRewardReq uid.
         * @member {number|Long} uid
         * @memberof protoCmd.mailRewardReq
         * @instance
         */
        mailRewardReq.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new mailRewardReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.mailRewardReq
         * @static
         * @param {protoCmd.ImailRewardReq=} [properties] Properties to set
         * @returns {protoCmd.mailRewardReq} mailRewardReq instance
         */
        mailRewardReq.create = function create(properties) {
            return new mailRewardReq(properties);
        };

        /**
         * Encodes the specified mailRewardReq message. Does not implicitly {@link protoCmd.mailRewardReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.mailRewardReq
         * @static
         * @param {protoCmd.ImailRewardReq} message mailRewardReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailRewardReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            return writer;
        };

        /**
         * Encodes the specified mailRewardReq message, length delimited. Does not implicitly {@link protoCmd.mailRewardReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.mailRewardReq
         * @static
         * @param {protoCmd.ImailRewardReq} message mailRewardReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailRewardReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mailRewardReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.mailRewardReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.mailRewardReq} mailRewardReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailRewardReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.mailRewardReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a mailRewardReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.mailRewardReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.mailRewardReq} mailRewardReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailRewardReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mailRewardReq message.
         * @function verify
         * @memberof protoCmd.mailRewardReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mailRewardReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            return null;
        };

        /**
         * Creates a mailRewardReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.mailRewardReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.mailRewardReq} mailRewardReq
         */
        mailRewardReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.mailRewardReq)
                return object;
            var message = new $root.protoCmd.mailRewardReq();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a mailRewardReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.mailRewardReq
         * @static
         * @param {protoCmd.mailRewardReq} message mailRewardReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        mailRewardReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            return object;
        };

        /**
         * Converts this mailRewardReq to JSON.
         * @function toJSON
         * @memberof protoCmd.mailRewardReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        mailRewardReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return mailRewardReq;
    })();

    protoCmd.mailRewardRes = (function() {

        /**
         * Properties of a mailRewardRes.
         * @memberof protoCmd
         * @interface ImailRewardRes
         * @property {number|Long|null} [uid] mailRewardRes uid
         */

        /**
         * Constructs a new mailRewardRes.
         * @memberof protoCmd
         * @classdesc Represents a mailRewardRes.
         * @implements ImailRewardRes
         * @constructor
         * @param {protoCmd.ImailRewardRes=} [properties] Properties to set
         */
        function mailRewardRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mailRewardRes uid.
         * @member {number|Long} uid
         * @memberof protoCmd.mailRewardRes
         * @instance
         */
        mailRewardRes.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new mailRewardRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.mailRewardRes
         * @static
         * @param {protoCmd.ImailRewardRes=} [properties] Properties to set
         * @returns {protoCmd.mailRewardRes} mailRewardRes instance
         */
        mailRewardRes.create = function create(properties) {
            return new mailRewardRes(properties);
        };

        /**
         * Encodes the specified mailRewardRes message. Does not implicitly {@link protoCmd.mailRewardRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.mailRewardRes
         * @static
         * @param {protoCmd.ImailRewardRes} message mailRewardRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailRewardRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            return writer;
        };

        /**
         * Encodes the specified mailRewardRes message, length delimited. Does not implicitly {@link protoCmd.mailRewardRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.mailRewardRes
         * @static
         * @param {protoCmd.ImailRewardRes} message mailRewardRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailRewardRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mailRewardRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.mailRewardRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.mailRewardRes} mailRewardRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailRewardRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.mailRewardRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a mailRewardRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.mailRewardRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.mailRewardRes} mailRewardRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailRewardRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mailRewardRes message.
         * @function verify
         * @memberof protoCmd.mailRewardRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mailRewardRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            return null;
        };

        /**
         * Creates a mailRewardRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.mailRewardRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.mailRewardRes} mailRewardRes
         */
        mailRewardRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.mailRewardRes)
                return object;
            var message = new $root.protoCmd.mailRewardRes();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a mailRewardRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.mailRewardRes
         * @static
         * @param {protoCmd.mailRewardRes} message mailRewardRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        mailRewardRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            return object;
        };

        /**
         * Converts this mailRewardRes to JSON.
         * @function toJSON
         * @memberof protoCmd.mailRewardRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        mailRewardRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return mailRewardRes;
    })();

    protoCmd.mailAllReq = (function() {

        /**
         * Properties of a mailAllReq.
         * @memberof protoCmd
         * @interface ImailAllReq
         */

        /**
         * Constructs a new mailAllReq.
         * @memberof protoCmd
         * @classdesc Represents a mailAllReq.
         * @implements ImailAllReq
         * @constructor
         * @param {protoCmd.ImailAllReq=} [properties] Properties to set
         */
        function mailAllReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new mailAllReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.mailAllReq
         * @static
         * @param {protoCmd.ImailAllReq=} [properties] Properties to set
         * @returns {protoCmd.mailAllReq} mailAllReq instance
         */
        mailAllReq.create = function create(properties) {
            return new mailAllReq(properties);
        };

        /**
         * Encodes the specified mailAllReq message. Does not implicitly {@link protoCmd.mailAllReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.mailAllReq
         * @static
         * @param {protoCmd.ImailAllReq} message mailAllReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailAllReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified mailAllReq message, length delimited. Does not implicitly {@link protoCmd.mailAllReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.mailAllReq
         * @static
         * @param {protoCmd.ImailAllReq} message mailAllReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailAllReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mailAllReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.mailAllReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.mailAllReq} mailAllReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailAllReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.mailAllReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a mailAllReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.mailAllReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.mailAllReq} mailAllReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailAllReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mailAllReq message.
         * @function verify
         * @memberof protoCmd.mailAllReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mailAllReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates a mailAllReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.mailAllReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.mailAllReq} mailAllReq
         */
        mailAllReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.mailAllReq)
                return object;
            return new $root.protoCmd.mailAllReq();
        };

        /**
         * Creates a plain object from a mailAllReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.mailAllReq
         * @static
         * @param {protoCmd.mailAllReq} message mailAllReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        mailAllReq.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this mailAllReq to JSON.
         * @function toJSON
         * @memberof protoCmd.mailAllReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        mailAllReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return mailAllReq;
    })();

    protoCmd.mailDelAllReq = (function() {

        /**
         * Properties of a mailDelAllReq.
         * @memberof protoCmd
         * @interface ImailDelAllReq
         */

        /**
         * Constructs a new mailDelAllReq.
         * @memberof protoCmd
         * @classdesc Represents a mailDelAllReq.
         * @implements ImailDelAllReq
         * @constructor
         * @param {protoCmd.ImailDelAllReq=} [properties] Properties to set
         */
        function mailDelAllReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new mailDelAllReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.mailDelAllReq
         * @static
         * @param {protoCmd.ImailDelAllReq=} [properties] Properties to set
         * @returns {protoCmd.mailDelAllReq} mailDelAllReq instance
         */
        mailDelAllReq.create = function create(properties) {
            return new mailDelAllReq(properties);
        };

        /**
         * Encodes the specified mailDelAllReq message. Does not implicitly {@link protoCmd.mailDelAllReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.mailDelAllReq
         * @static
         * @param {protoCmd.ImailDelAllReq} message mailDelAllReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailDelAllReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified mailDelAllReq message, length delimited. Does not implicitly {@link protoCmd.mailDelAllReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.mailDelAllReq
         * @static
         * @param {protoCmd.ImailDelAllReq} message mailDelAllReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mailDelAllReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mailDelAllReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.mailDelAllReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.mailDelAllReq} mailDelAllReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailDelAllReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.mailDelAllReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a mailDelAllReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.mailDelAllReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.mailDelAllReq} mailDelAllReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mailDelAllReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mailDelAllReq message.
         * @function verify
         * @memberof protoCmd.mailDelAllReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mailDelAllReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates a mailDelAllReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.mailDelAllReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.mailDelAllReq} mailDelAllReq
         */
        mailDelAllReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.mailDelAllReq)
                return object;
            return new $root.protoCmd.mailDelAllReq();
        };

        /**
         * Creates a plain object from a mailDelAllReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.mailDelAllReq
         * @static
         * @param {protoCmd.mailDelAllReq} message mailDelAllReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        mailDelAllReq.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this mailDelAllReq to JSON.
         * @function toJSON
         * @memberof protoCmd.mailDelAllReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        mailDelAllReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return mailDelAllReq;
    })();

    protoCmd.friendSyn = (function() {

        /**
         * Properties of a friendSyn.
         * @memberof protoCmd
         * @interface IfriendSyn
         * @property {Array.<protoCmd.IfriendDict>|null} [friendList] friendSyn friendList
         * @property {Array.<protoCmd.IfriendDict>|null} [applyList] friendSyn applyList
         */

        /**
         * Constructs a new friendSyn.
         * @memberof protoCmd
         * @classdesc Represents a friendSyn.
         * @implements IfriendSyn
         * @constructor
         * @param {protoCmd.IfriendSyn=} [properties] Properties to set
         */
        function friendSyn(properties) {
            this.friendList = [];
            this.applyList = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * friendSyn friendList.
         * @member {Array.<protoCmd.IfriendDict>} friendList
         * @memberof protoCmd.friendSyn
         * @instance
         */
        friendSyn.prototype.friendList = $util.emptyArray;

        /**
         * friendSyn applyList.
         * @member {Array.<protoCmd.IfriendDict>} applyList
         * @memberof protoCmd.friendSyn
         * @instance
         */
        friendSyn.prototype.applyList = $util.emptyArray;

        /**
         * Creates a new friendSyn instance using the specified properties.
         * @function create
         * @memberof protoCmd.friendSyn
         * @static
         * @param {protoCmd.IfriendSyn=} [properties] Properties to set
         * @returns {protoCmd.friendSyn} friendSyn instance
         */
        friendSyn.create = function create(properties) {
            return new friendSyn(properties);
        };

        /**
         * Encodes the specified friendSyn message. Does not implicitly {@link protoCmd.friendSyn.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.friendSyn
         * @static
         * @param {protoCmd.IfriendSyn} message friendSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendSyn.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.friendList != null && message.friendList.length)
                for (var i = 0; i < message.friendList.length; ++i)
                    $root.protoCmd.friendDict.encode(message.friendList[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
            if (message.applyList != null && message.applyList.length)
                for (var i = 0; i < message.applyList.length; ++i)
                    $root.protoCmd.friendDict.encode(message.applyList[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified friendSyn message, length delimited. Does not implicitly {@link protoCmd.friendSyn.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.friendSyn
         * @static
         * @param {protoCmd.IfriendSyn} message friendSyn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendSyn.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a friendSyn message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.friendSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.friendSyn} friendSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendSyn.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.friendSyn();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    if (!(message.friendList && message.friendList.length))
                        message.friendList = [];
                    message.friendList.push($root.protoCmd.friendDict.decode(reader, reader.uint32()));
                    break;
                case 2:
                    if (!(message.applyList && message.applyList.length))
                        message.applyList = [];
                    message.applyList.push($root.protoCmd.friendDict.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a friendSyn message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.friendSyn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.friendSyn} friendSyn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendSyn.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a friendSyn message.
         * @function verify
         * @memberof protoCmd.friendSyn
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        friendSyn.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.friendList != null && message.hasOwnProperty("friendList")) {
                if (!Array.isArray(message.friendList))
                    return "friendList: array expected";
                for (var i = 0; i < message.friendList.length; ++i) {
                    var error = $root.protoCmd.friendDict.verify(message.friendList[i]);
                    if (error)
                        return "friendList." + error;
                }
            }
            if (message.applyList != null && message.hasOwnProperty("applyList")) {
                if (!Array.isArray(message.applyList))
                    return "applyList: array expected";
                for (var i = 0; i < message.applyList.length; ++i) {
                    var error = $root.protoCmd.friendDict.verify(message.applyList[i]);
                    if (error)
                        return "applyList." + error;
                }
            }
            return null;
        };

        /**
         * Creates a friendSyn message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.friendSyn
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.friendSyn} friendSyn
         */
        friendSyn.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.friendSyn)
                return object;
            var message = new $root.protoCmd.friendSyn();
            if (object.friendList) {
                if (!Array.isArray(object.friendList))
                    throw TypeError(".protoCmd.friendSyn.friendList: array expected");
                message.friendList = [];
                for (var i = 0; i < object.friendList.length; ++i) {
                    if (typeof object.friendList[i] !== "object")
                        throw TypeError(".protoCmd.friendSyn.friendList: object expected");
                    message.friendList[i] = $root.protoCmd.friendDict.fromObject(object.friendList[i]);
                }
            }
            if (object.applyList) {
                if (!Array.isArray(object.applyList))
                    throw TypeError(".protoCmd.friendSyn.applyList: array expected");
                message.applyList = [];
                for (var i = 0; i < object.applyList.length; ++i) {
                    if (typeof object.applyList[i] !== "object")
                        throw TypeError(".protoCmd.friendSyn.applyList: object expected");
                    message.applyList[i] = $root.protoCmd.friendDict.fromObject(object.applyList[i]);
                }
            }
            return message;
        };

        /**
         * Creates a plain object from a friendSyn message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.friendSyn
         * @static
         * @param {protoCmd.friendSyn} message friendSyn
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        friendSyn.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.arrays || options.defaults) {
                object.friendList = [];
                object.applyList = [];
            }
            if (message.friendList && message.friendList.length) {
                object.friendList = [];
                for (var j = 0; j < message.friendList.length; ++j)
                    object.friendList[j] = $root.protoCmd.friendDict.toObject(message.friendList[j], options);
            }
            if (message.applyList && message.applyList.length) {
                object.applyList = [];
                for (var j = 0; j < message.applyList.length; ++j)
                    object.applyList[j] = $root.protoCmd.friendDict.toObject(message.applyList[j], options);
            }
            return object;
        };

        /**
         * Converts this friendSyn to JSON.
         * @function toJSON
         * @memberof protoCmd.friendSyn
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        friendSyn.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return friendSyn;
    })();

    protoCmd.friendDict = (function() {

        /**
         * Properties of a friendDict.
         * @memberof protoCmd
         * @interface IfriendDict
         * @property {number|Long|null} [uid] friendDict uid
         * @property {string|null} [name] friendDict name
         * @property {number|Long|null} [level] friendDict level
         * @property {boolean|null} [online] friendDict online
         * @property {number|Long|null} [head] friendDict head
         * @property {number|Long|null} [lastTime] friendDict lastTime
         */

        /**
         * Constructs a new friendDict.
         * @memberof protoCmd
         * @classdesc Represents a friendDict.
         * @implements IfriendDict
         * @constructor
         * @param {protoCmd.IfriendDict=} [properties] Properties to set
         */
        function friendDict(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * friendDict uid.
         * @member {number|Long} uid
         * @memberof protoCmd.friendDict
         * @instance
         */
        friendDict.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * friendDict name.
         * @member {string} name
         * @memberof protoCmd.friendDict
         * @instance
         */
        friendDict.prototype.name = "";

        /**
         * friendDict level.
         * @member {number|Long} level
         * @memberof protoCmd.friendDict
         * @instance
         */
        friendDict.prototype.level = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * friendDict online.
         * @member {boolean} online
         * @memberof protoCmd.friendDict
         * @instance
         */
        friendDict.prototype.online = false;

        /**
         * friendDict head.
         * @member {number|Long} head
         * @memberof protoCmd.friendDict
         * @instance
         */
        friendDict.prototype.head = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * friendDict lastTime.
         * @member {number|Long} lastTime
         * @memberof protoCmd.friendDict
         * @instance
         */
        friendDict.prototype.lastTime = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new friendDict instance using the specified properties.
         * @function create
         * @memberof protoCmd.friendDict
         * @static
         * @param {protoCmd.IfriendDict=} [properties] Properties to set
         * @returns {protoCmd.friendDict} friendDict instance
         */
        friendDict.create = function create(properties) {
            return new friendDict(properties);
        };

        /**
         * Encodes the specified friendDict message. Does not implicitly {@link protoCmd.friendDict.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.friendDict
         * @static
         * @param {protoCmd.IfriendDict} message friendDict message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendDict.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            if (message.name != null && Object.hasOwnProperty.call(message, "name"))
                writer.uint32(/* id 2, wireType 2 =*/18).string(message.name);
            if (message.level != null && Object.hasOwnProperty.call(message, "level"))
                writer.uint32(/* id 3, wireType 0 =*/24).uint64(message.level);
            if (message.online != null && Object.hasOwnProperty.call(message, "online"))
                writer.uint32(/* id 4, wireType 0 =*/32).bool(message.online);
            if (message.head != null && Object.hasOwnProperty.call(message, "head"))
                writer.uint32(/* id 5, wireType 0 =*/40).uint64(message.head);
            if (message.lastTime != null && Object.hasOwnProperty.call(message, "lastTime"))
                writer.uint32(/* id 6, wireType 0 =*/48).uint64(message.lastTime);
            return writer;
        };

        /**
         * Encodes the specified friendDict message, length delimited. Does not implicitly {@link protoCmd.friendDict.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.friendDict
         * @static
         * @param {protoCmd.IfriendDict} message friendDict message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendDict.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a friendDict message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.friendDict
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.friendDict} friendDict
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendDict.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.friendDict();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                case 2:
                    message.name = reader.string();
                    break;
                case 3:
                    message.level = reader.uint64();
                    break;
                case 4:
                    message.online = reader.bool();
                    break;
                case 5:
                    message.head = reader.uint64();
                    break;
                case 6:
                    message.lastTime = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a friendDict message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.friendDict
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.friendDict} friendDict
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendDict.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a friendDict message.
         * @function verify
         * @memberof protoCmd.friendDict
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        friendDict.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            if (message.name != null && message.hasOwnProperty("name"))
                if (!$util.isString(message.name))
                    return "name: string expected";
            if (message.level != null && message.hasOwnProperty("level"))
                if (!$util.isInteger(message.level) && !(message.level && $util.isInteger(message.level.low) && $util.isInteger(message.level.high)))
                    return "level: integer|Long expected";
            if (message.online != null && message.hasOwnProperty("online"))
                if (typeof message.online !== "boolean")
                    return "online: boolean expected";
            if (message.head != null && message.hasOwnProperty("head"))
                if (!$util.isInteger(message.head) && !(message.head && $util.isInteger(message.head.low) && $util.isInteger(message.head.high)))
                    return "head: integer|Long expected";
            if (message.lastTime != null && message.hasOwnProperty("lastTime"))
                if (!$util.isInteger(message.lastTime) && !(message.lastTime && $util.isInteger(message.lastTime.low) && $util.isInteger(message.lastTime.high)))
                    return "lastTime: integer|Long expected";
            return null;
        };

        /**
         * Creates a friendDict message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.friendDict
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.friendDict} friendDict
         */
        friendDict.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.friendDict)
                return object;
            var message = new $root.protoCmd.friendDict();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            if (object.name != null)
                message.name = String(object.name);
            if (object.level != null)
                if ($util.Long)
                    (message.level = $util.Long.fromValue(object.level)).unsigned = true;
                else if (typeof object.level === "string")
                    message.level = parseInt(object.level, 10);
                else if (typeof object.level === "number")
                    message.level = object.level;
                else if (typeof object.level === "object")
                    message.level = new $util.LongBits(object.level.low >>> 0, object.level.high >>> 0).toNumber(true);
            if (object.online != null)
                message.online = Boolean(object.online);
            if (object.head != null)
                if ($util.Long)
                    (message.head = $util.Long.fromValue(object.head)).unsigned = true;
                else if (typeof object.head === "string")
                    message.head = parseInt(object.head, 10);
                else if (typeof object.head === "number")
                    message.head = object.head;
                else if (typeof object.head === "object")
                    message.head = new $util.LongBits(object.head.low >>> 0, object.head.high >>> 0).toNumber(true);
            if (object.lastTime != null)
                if ($util.Long)
                    (message.lastTime = $util.Long.fromValue(object.lastTime)).unsigned = true;
                else if (typeof object.lastTime === "string")
                    message.lastTime = parseInt(object.lastTime, 10);
                else if (typeof object.lastTime === "number")
                    message.lastTime = object.lastTime;
                else if (typeof object.lastTime === "object")
                    message.lastTime = new $util.LongBits(object.lastTime.low >>> 0, object.lastTime.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a friendDict message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.friendDict
         * @static
         * @param {protoCmd.friendDict} message friendDict
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        friendDict.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
                object.name = "";
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.level = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.level = options.longs === String ? "0" : 0;
                object.online = false;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.head = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.head = options.longs === String ? "0" : 0;
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.lastTime = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.lastTime = options.longs === String ? "0" : 0;
            }
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            if (message.name != null && message.hasOwnProperty("name"))
                object.name = message.name;
            if (message.level != null && message.hasOwnProperty("level"))
                if (typeof message.level === "number")
                    object.level = options.longs === String ? String(message.level) : message.level;
                else
                    object.level = options.longs === String ? $util.Long.prototype.toString.call(message.level) : options.longs === Number ? new $util.LongBits(message.level.low >>> 0, message.level.high >>> 0).toNumber(true) : message.level;
            if (message.online != null && message.hasOwnProperty("online"))
                object.online = message.online;
            if (message.head != null && message.hasOwnProperty("head"))
                if (typeof message.head === "number")
                    object.head = options.longs === String ? String(message.head) : message.head;
                else
                    object.head = options.longs === String ? $util.Long.prototype.toString.call(message.head) : options.longs === Number ? new $util.LongBits(message.head.low >>> 0, message.head.high >>> 0).toNumber(true) : message.head;
            if (message.lastTime != null && message.hasOwnProperty("lastTime"))
                if (typeof message.lastTime === "number")
                    object.lastTime = options.longs === String ? String(message.lastTime) : message.lastTime;
                else
                    object.lastTime = options.longs === String ? $util.Long.prototype.toString.call(message.lastTime) : options.longs === Number ? new $util.LongBits(message.lastTime.low >>> 0, message.lastTime.high >>> 0).toNumber(true) : message.lastTime;
            return object;
        };

        /**
         * Converts this friendDict to JSON.
         * @function toJSON
         * @memberof protoCmd.friendDict
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        friendDict.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return friendDict;
    })();

    protoCmd.friendReq = (function() {

        /**
         * Properties of a friendReq.
         * @memberof protoCmd
         * @interface IfriendReq
         * @property {number|Long|null} [uid] friendReq uid
         */

        /**
         * Constructs a new friendReq.
         * @memberof protoCmd
         * @classdesc Represents a friendReq.
         * @implements IfriendReq
         * @constructor
         * @param {protoCmd.IfriendReq=} [properties] Properties to set
         */
        function friendReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * friendReq uid.
         * @member {number|Long} uid
         * @memberof protoCmd.friendReq
         * @instance
         */
        friendReq.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new friendReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.friendReq
         * @static
         * @param {protoCmd.IfriendReq=} [properties] Properties to set
         * @returns {protoCmd.friendReq} friendReq instance
         */
        friendReq.create = function create(properties) {
            return new friendReq(properties);
        };

        /**
         * Encodes the specified friendReq message. Does not implicitly {@link protoCmd.friendReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.friendReq
         * @static
         * @param {protoCmd.IfriendReq} message friendReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            return writer;
        };

        /**
         * Encodes the specified friendReq message, length delimited. Does not implicitly {@link protoCmd.friendReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.friendReq
         * @static
         * @param {protoCmd.IfriendReq} message friendReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a friendReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.friendReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.friendReq} friendReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.friendReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a friendReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.friendReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.friendReq} friendReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a friendReq message.
         * @function verify
         * @memberof protoCmd.friendReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        friendReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            return null;
        };

        /**
         * Creates a friendReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.friendReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.friendReq} friendReq
         */
        friendReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.friendReq)
                return object;
            var message = new $root.protoCmd.friendReq();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a friendReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.friendReq
         * @static
         * @param {protoCmd.friendReq} message friendReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        friendReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            return object;
        };

        /**
         * Converts this friendReq to JSON.
         * @function toJSON
         * @memberof protoCmd.friendReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        friendReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return friendReq;
    })();

    protoCmd.friendRes = (function() {

        /**
         * Properties of a friendRes.
         * @memberof protoCmd
         * @interface IfriendRes
         * @property {protoCmd.IuserInfoSyn|null} [info] friendRes info
         */

        /**
         * Constructs a new friendRes.
         * @memberof protoCmd
         * @classdesc Represents a friendRes.
         * @implements IfriendRes
         * @constructor
         * @param {protoCmd.IfriendRes=} [properties] Properties to set
         */
        function friendRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * friendRes info.
         * @member {protoCmd.IuserInfoSyn|null|undefined} info
         * @memberof protoCmd.friendRes
         * @instance
         */
        friendRes.prototype.info = null;

        /**
         * Creates a new friendRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.friendRes
         * @static
         * @param {protoCmd.IfriendRes=} [properties] Properties to set
         * @returns {protoCmd.friendRes} friendRes instance
         */
        friendRes.create = function create(properties) {
            return new friendRes(properties);
        };

        /**
         * Encodes the specified friendRes message. Does not implicitly {@link protoCmd.friendRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.friendRes
         * @static
         * @param {protoCmd.IfriendRes} message friendRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.info != null && Object.hasOwnProperty.call(message, "info"))
                $root.protoCmd.userInfoSyn.encode(message.info, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified friendRes message, length delimited. Does not implicitly {@link protoCmd.friendRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.friendRes
         * @static
         * @param {protoCmd.IfriendRes} message friendRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a friendRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.friendRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.friendRes} friendRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.friendRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.info = $root.protoCmd.userInfoSyn.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a friendRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.friendRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.friendRes} friendRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a friendRes message.
         * @function verify
         * @memberof protoCmd.friendRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        friendRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.info != null && message.hasOwnProperty("info")) {
                var error = $root.protoCmd.userInfoSyn.verify(message.info);
                if (error)
                    return "info." + error;
            }
            return null;
        };

        /**
         * Creates a friendRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.friendRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.friendRes} friendRes
         */
        friendRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.friendRes)
                return object;
            var message = new $root.protoCmd.friendRes();
            if (object.info != null) {
                if (typeof object.info !== "object")
                    throw TypeError(".protoCmd.friendRes.info: object expected");
                message.info = $root.protoCmd.userInfoSyn.fromObject(object.info);
            }
            return message;
        };

        /**
         * Creates a plain object from a friendRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.friendRes
         * @static
         * @param {protoCmd.friendRes} message friendRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        friendRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                object.info = null;
            if (message.info != null && message.hasOwnProperty("info"))
                object.info = $root.protoCmd.userInfoSyn.toObject(message.info, options);
            return object;
        };

        /**
         * Converts this friendRes to JSON.
         * @function toJSON
         * @memberof protoCmd.friendRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        friendRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return friendRes;
    })();

    protoCmd.friendAddReq = (function() {

        /**
         * Properties of a friendAddReq.
         * @memberof protoCmd
         * @interface IfriendAddReq
         * @property {number|Long|null} [uid] friendAddReq uid
         */

        /**
         * Constructs a new friendAddReq.
         * @memberof protoCmd
         * @classdesc Represents a friendAddReq.
         * @implements IfriendAddReq
         * @constructor
         * @param {protoCmd.IfriendAddReq=} [properties] Properties to set
         */
        function friendAddReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * friendAddReq uid.
         * @member {number|Long} uid
         * @memberof protoCmd.friendAddReq
         * @instance
         */
        friendAddReq.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new friendAddReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.friendAddReq
         * @static
         * @param {protoCmd.IfriendAddReq=} [properties] Properties to set
         * @returns {protoCmd.friendAddReq} friendAddReq instance
         */
        friendAddReq.create = function create(properties) {
            return new friendAddReq(properties);
        };

        /**
         * Encodes the specified friendAddReq message. Does not implicitly {@link protoCmd.friendAddReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.friendAddReq
         * @static
         * @param {protoCmd.IfriendAddReq} message friendAddReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendAddReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            return writer;
        };

        /**
         * Encodes the specified friendAddReq message, length delimited. Does not implicitly {@link protoCmd.friendAddReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.friendAddReq
         * @static
         * @param {protoCmd.IfriendAddReq} message friendAddReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendAddReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a friendAddReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.friendAddReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.friendAddReq} friendAddReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendAddReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.friendAddReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a friendAddReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.friendAddReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.friendAddReq} friendAddReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendAddReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a friendAddReq message.
         * @function verify
         * @memberof protoCmd.friendAddReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        friendAddReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            return null;
        };

        /**
         * Creates a friendAddReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.friendAddReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.friendAddReq} friendAddReq
         */
        friendAddReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.friendAddReq)
                return object;
            var message = new $root.protoCmd.friendAddReq();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from a friendAddReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.friendAddReq
         * @static
         * @param {protoCmd.friendAddReq} message friendAddReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        friendAddReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            return object;
        };

        /**
         * Converts this friendAddReq to JSON.
         * @function toJSON
         * @memberof protoCmd.friendAddReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        friendAddReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return friendAddReq;
    })();

    protoCmd.friendAddRes = (function() {

        /**
         * Properties of a friendAddRes.
         * @memberof protoCmd
         * @interface IfriendAddRes
         * @property {boolean|null} [status] friendAddRes status
         * @property {string|null} [errorMessage] friendAddRes errorMessage
         */

        /**
         * Constructs a new friendAddRes.
         * @memberof protoCmd
         * @classdesc Represents a friendAddRes.
         * @implements IfriendAddRes
         * @constructor
         * @param {protoCmd.IfriendAddRes=} [properties] Properties to set
         */
        function friendAddRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * friendAddRes status.
         * @member {boolean} status
         * @memberof protoCmd.friendAddRes
         * @instance
         */
        friendAddRes.prototype.status = false;

        /**
         * friendAddRes errorMessage.
         * @member {string} errorMessage
         * @memberof protoCmd.friendAddRes
         * @instance
         */
        friendAddRes.prototype.errorMessage = "";

        /**
         * Creates a new friendAddRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.friendAddRes
         * @static
         * @param {protoCmd.IfriendAddRes=} [properties] Properties to set
         * @returns {protoCmd.friendAddRes} friendAddRes instance
         */
        friendAddRes.create = function create(properties) {
            return new friendAddRes(properties);
        };

        /**
         * Encodes the specified friendAddRes message. Does not implicitly {@link protoCmd.friendAddRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.friendAddRes
         * @static
         * @param {protoCmd.IfriendAddRes} message friendAddRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendAddRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.status != null && Object.hasOwnProperty.call(message, "status"))
                writer.uint32(/* id 1, wireType 0 =*/8).bool(message.status);
            if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage"))
                writer.uint32(/* id 2, wireType 2 =*/18).string(message.errorMessage);
            return writer;
        };

        /**
         * Encodes the specified friendAddRes message, length delimited. Does not implicitly {@link protoCmd.friendAddRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.friendAddRes
         * @static
         * @param {protoCmd.IfriendAddRes} message friendAddRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendAddRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a friendAddRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.friendAddRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.friendAddRes} friendAddRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendAddRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.friendAddRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.status = reader.bool();
                    break;
                case 2:
                    message.errorMessage = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a friendAddRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.friendAddRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.friendAddRes} friendAddRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendAddRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a friendAddRes message.
         * @function verify
         * @memberof protoCmd.friendAddRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        friendAddRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.status != null && message.hasOwnProperty("status"))
                if (typeof message.status !== "boolean")
                    return "status: boolean expected";
            if (message.errorMessage != null && message.hasOwnProperty("errorMessage"))
                if (!$util.isString(message.errorMessage))
                    return "errorMessage: string expected";
            return null;
        };

        /**
         * Creates a friendAddRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.friendAddRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.friendAddRes} friendAddRes
         */
        friendAddRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.friendAddRes)
                return object;
            var message = new $root.protoCmd.friendAddRes();
            if (object.status != null)
                message.status = Boolean(object.status);
            if (object.errorMessage != null)
                message.errorMessage = String(object.errorMessage);
            return message;
        };

        /**
         * Creates a plain object from a friendAddRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.friendAddRes
         * @static
         * @param {protoCmd.friendAddRes} message friendAddRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        friendAddRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                object.status = false;
                object.errorMessage = "";
            }
            if (message.status != null && message.hasOwnProperty("status"))
                object.status = message.status;
            if (message.errorMessage != null && message.hasOwnProperty("errorMessage"))
                object.errorMessage = message.errorMessage;
            return object;
        };

        /**
         * Converts this friendAddRes to JSON.
         * @function toJSON
         * @memberof protoCmd.friendAddRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        friendAddRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return friendAddRes;
    })();

    protoCmd.friendDelReq = (function() {

        /**
         * Properties of a friendDelReq.
         * @memberof protoCmd
         * @interface IfriendDelReq
         * @property {number|Long|null} [uid] friendDelReq uid
         * @property {boolean|null} [isApply] friendDelReq isApply
         */

        /**
         * Constructs a new friendDelReq.
         * @memberof protoCmd
         * @classdesc Represents a friendDelReq.
         * @implements IfriendDelReq
         * @constructor
         * @param {protoCmd.IfriendDelReq=} [properties] Properties to set
         */
        function friendDelReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * friendDelReq uid.
         * @member {number|Long} uid
         * @memberof protoCmd.friendDelReq
         * @instance
         */
        friendDelReq.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * friendDelReq isApply.
         * @member {boolean} isApply
         * @memberof protoCmd.friendDelReq
         * @instance
         */
        friendDelReq.prototype.isApply = false;

        /**
         * Creates a new friendDelReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.friendDelReq
         * @static
         * @param {protoCmd.IfriendDelReq=} [properties] Properties to set
         * @returns {protoCmd.friendDelReq} friendDelReq instance
         */
        friendDelReq.create = function create(properties) {
            return new friendDelReq(properties);
        };

        /**
         * Encodes the specified friendDelReq message. Does not implicitly {@link protoCmd.friendDelReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.friendDelReq
         * @static
         * @param {protoCmd.IfriendDelReq} message friendDelReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendDelReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            if (message.isApply != null && Object.hasOwnProperty.call(message, "isApply"))
                writer.uint32(/* id 2, wireType 0 =*/16).bool(message.isApply);
            return writer;
        };

        /**
         * Encodes the specified friendDelReq message, length delimited. Does not implicitly {@link protoCmd.friendDelReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.friendDelReq
         * @static
         * @param {protoCmd.IfriendDelReq} message friendDelReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        friendDelReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a friendDelReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.friendDelReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.friendDelReq} friendDelReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendDelReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.friendDelReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                case 2:
                    message.isApply = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a friendDelReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.friendDelReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.friendDelReq} friendDelReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        friendDelReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a friendDelReq message.
         * @function verify
         * @memberof protoCmd.friendDelReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        friendDelReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            if (message.isApply != null && message.hasOwnProperty("isApply"))
                if (typeof message.isApply !== "boolean")
                    return "isApply: boolean expected";
            return null;
        };

        /**
         * Creates a friendDelReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.friendDelReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.friendDelReq} friendDelReq
         */
        friendDelReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.friendDelReq)
                return object;
            var message = new $root.protoCmd.friendDelReq();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            if (object.isApply != null)
                message.isApply = Boolean(object.isApply);
            return message;
        };

        /**
         * Creates a plain object from a friendDelReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.friendDelReq
         * @static
         * @param {protoCmd.friendDelReq} message friendDelReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        friendDelReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
                object.isApply = false;
            }
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            if (message.isApply != null && message.hasOwnProperty("isApply"))
                object.isApply = message.isApply;
            return object;
        };

        /**
         * Converts this friendDelReq to JSON.
         * @function toJSON
         * @memberof protoCmd.friendDelReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        friendDelReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return friendDelReq;
    })();

    protoCmd.tempFriendReq = (function() {

        /**
         * Properties of a tempFriendReq.
         * @memberof protoCmd
         * @interface ItempFriendReq
         */

        /**
         * Constructs a new tempFriendReq.
         * @memberof protoCmd
         * @classdesc Represents a tempFriendReq.
         * @implements ItempFriendReq
         * @constructor
         * @param {protoCmd.ItempFriendReq=} [properties] Properties to set
         */
        function tempFriendReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Creates a new tempFriendReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.tempFriendReq
         * @static
         * @param {protoCmd.ItempFriendReq=} [properties] Properties to set
         * @returns {protoCmd.tempFriendReq} tempFriendReq instance
         */
        tempFriendReq.create = function create(properties) {
            return new tempFriendReq(properties);
        };

        /**
         * Encodes the specified tempFriendReq message. Does not implicitly {@link protoCmd.tempFriendReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.tempFriendReq
         * @static
         * @param {protoCmd.ItempFriendReq} message tempFriendReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        tempFriendReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            return writer;
        };

        /**
         * Encodes the specified tempFriendReq message, length delimited. Does not implicitly {@link protoCmd.tempFriendReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.tempFriendReq
         * @static
         * @param {protoCmd.ItempFriendReq} message tempFriendReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        tempFriendReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a tempFriendReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.tempFriendReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.tempFriendReq} tempFriendReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        tempFriendReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.tempFriendReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a tempFriendReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.tempFriendReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.tempFriendReq} tempFriendReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        tempFriendReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a tempFriendReq message.
         * @function verify
         * @memberof protoCmd.tempFriendReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        tempFriendReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            return null;
        };

        /**
         * Creates a tempFriendReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.tempFriendReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.tempFriendReq} tempFriendReq
         */
        tempFriendReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.tempFriendReq)
                return object;
            return new $root.protoCmd.tempFriendReq();
        };

        /**
         * Creates a plain object from a tempFriendReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.tempFriendReq
         * @static
         * @param {protoCmd.tempFriendReq} message tempFriendReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        tempFriendReq.toObject = function toObject() {
            return {};
        };

        /**
         * Converts this tempFriendReq to JSON.
         * @function toJSON
         * @memberof protoCmd.tempFriendReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        tempFriendReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return tempFriendReq;
    })();

    protoCmd.tempFriendRes = (function() {

        /**
         * Properties of a tempFriendRes.
         * @memberof protoCmd
         * @interface ItempFriendRes
         * @property {Array.<protoCmd.IfriendDict>|null} [tempfriendList] tempFriendRes tempfriendList
         */

        /**
         * Constructs a new tempFriendRes.
         * @memberof protoCmd
         * @classdesc Represents a tempFriendRes.
         * @implements ItempFriendRes
         * @constructor
         * @param {protoCmd.ItempFriendRes=} [properties] Properties to set
         */
        function tempFriendRes(properties) {
            this.tempfriendList = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * tempFriendRes tempfriendList.
         * @member {Array.<protoCmd.IfriendDict>} tempfriendList
         * @memberof protoCmd.tempFriendRes
         * @instance
         */
        tempFriendRes.prototype.tempfriendList = $util.emptyArray;

        /**
         * Creates a new tempFriendRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.tempFriendRes
         * @static
         * @param {protoCmd.ItempFriendRes=} [properties] Properties to set
         * @returns {protoCmd.tempFriendRes} tempFriendRes instance
         */
        tempFriendRes.create = function create(properties) {
            return new tempFriendRes(properties);
        };

        /**
         * Encodes the specified tempFriendRes message. Does not implicitly {@link protoCmd.tempFriendRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.tempFriendRes
         * @static
         * @param {protoCmd.ItempFriendRes} message tempFriendRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        tempFriendRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.tempfriendList != null && message.tempfriendList.length)
                for (var i = 0; i < message.tempfriendList.length; ++i)
                    $root.protoCmd.friendDict.encode(message.tempfriendList[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified tempFriendRes message, length delimited. Does not implicitly {@link protoCmd.tempFriendRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.tempFriendRes
         * @static
         * @param {protoCmd.ItempFriendRes} message tempFriendRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        tempFriendRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a tempFriendRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.tempFriendRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.tempFriendRes} tempFriendRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        tempFriendRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.tempFriendRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    if (!(message.tempfriendList && message.tempfriendList.length))
                        message.tempfriendList = [];
                    message.tempfriendList.push($root.protoCmd.friendDict.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a tempFriendRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.tempFriendRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.tempFriendRes} tempFriendRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        tempFriendRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a tempFriendRes message.
         * @function verify
         * @memberof protoCmd.tempFriendRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        tempFriendRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.tempfriendList != null && message.hasOwnProperty("tempfriendList")) {
                if (!Array.isArray(message.tempfriendList))
                    return "tempfriendList: array expected";
                for (var i = 0; i < message.tempfriendList.length; ++i) {
                    var error = $root.protoCmd.friendDict.verify(message.tempfriendList[i]);
                    if (error)
                        return "tempfriendList." + error;
                }
            }
            return null;
        };

        /**
         * Creates a tempFriendRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.tempFriendRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.tempFriendRes} tempFriendRes
         */
        tempFriendRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.tempFriendRes)
                return object;
            var message = new $root.protoCmd.tempFriendRes();
            if (object.tempfriendList) {
                if (!Array.isArray(object.tempfriendList))
                    throw TypeError(".protoCmd.tempFriendRes.tempfriendList: array expected");
                message.tempfriendList = [];
                for (var i = 0; i < object.tempfriendList.length; ++i) {
                    if (typeof object.tempfriendList[i] !== "object")
                        throw TypeError(".protoCmd.tempFriendRes.tempfriendList: object expected");
                    message.tempfriendList[i] = $root.protoCmd.friendDict.fromObject(object.tempfriendList[i]);
                }
            }
            return message;
        };

        /**
         * Creates a plain object from a tempFriendRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.tempFriendRes
         * @static
         * @param {protoCmd.tempFriendRes} message tempFriendRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        tempFriendRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.arrays || options.defaults)
                object.tempfriendList = [];
            if (message.tempfriendList && message.tempfriendList.length) {
                object.tempfriendList = [];
                for (var j = 0; j < message.tempfriendList.length; ++j)
                    object.tempfriendList[j] = $root.protoCmd.friendDict.toObject(message.tempfriendList[j], options);
            }
            return object;
        };

        /**
         * Converts this tempFriendRes to JSON.
         * @function toJSON
         * @memberof protoCmd.tempFriendRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        tempFriendRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return tempFriendRes;
    })();

    protoCmd.addTempFriendReq = (function() {

        /**
         * Properties of an addTempFriendReq.
         * @memberof protoCmd
         * @interface IaddTempFriendReq
         * @property {number|Long|null} [uid] addTempFriendReq uid
         */

        /**
         * Constructs a new addTempFriendReq.
         * @memberof protoCmd
         * @classdesc Represents an addTempFriendReq.
         * @implements IaddTempFriendReq
         * @constructor
         * @param {protoCmd.IaddTempFriendReq=} [properties] Properties to set
         */
        function addTempFriendReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * addTempFriendReq uid.
         * @member {number|Long} uid
         * @memberof protoCmd.addTempFriendReq
         * @instance
         */
        addTempFriendReq.prototype.uid = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

        /**
         * Creates a new addTempFriendReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.addTempFriendReq
         * @static
         * @param {protoCmd.IaddTempFriendReq=} [properties] Properties to set
         * @returns {protoCmd.addTempFriendReq} addTempFriendReq instance
         */
        addTempFriendReq.create = function create(properties) {
            return new addTempFriendReq(properties);
        };

        /**
         * Encodes the specified addTempFriendReq message. Does not implicitly {@link protoCmd.addTempFriendReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.addTempFriendReq
         * @static
         * @param {protoCmd.IaddTempFriendReq} message addTempFriendReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        addTempFriendReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.uid != null && Object.hasOwnProperty.call(message, "uid"))
                writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.uid);
            return writer;
        };

        /**
         * Encodes the specified addTempFriendReq message, length delimited. Does not implicitly {@link protoCmd.addTempFriendReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.addTempFriendReq
         * @static
         * @param {protoCmd.IaddTempFriendReq} message addTempFriendReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        addTempFriendReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an addTempFriendReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.addTempFriendReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.addTempFriendReq} addTempFriendReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        addTempFriendReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.addTempFriendReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes an addTempFriendReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.addTempFriendReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.addTempFriendReq} addTempFriendReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        addTempFriendReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an addTempFriendReq message.
         * @function verify
         * @memberof protoCmd.addTempFriendReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        addTempFriendReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (!$util.isInteger(message.uid) && !(message.uid && $util.isInteger(message.uid.low) && $util.isInteger(message.uid.high)))
                    return "uid: integer|Long expected";
            return null;
        };

        /**
         * Creates an addTempFriendReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.addTempFriendReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.addTempFriendReq} addTempFriendReq
         */
        addTempFriendReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.addTempFriendReq)
                return object;
            var message = new $root.protoCmd.addTempFriendReq();
            if (object.uid != null)
                if ($util.Long)
                    (message.uid = $util.Long.fromValue(object.uid)).unsigned = true;
                else if (typeof object.uid === "string")
                    message.uid = parseInt(object.uid, 10);
                else if (typeof object.uid === "number")
                    message.uid = object.uid;
                else if (typeof object.uid === "object")
                    message.uid = new $util.LongBits(object.uid.low >>> 0, object.uid.high >>> 0).toNumber(true);
            return message;
        };

        /**
         * Creates a plain object from an addTempFriendReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.addTempFriendReq
         * @static
         * @param {protoCmd.addTempFriendReq} message addTempFriendReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        addTempFriendReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                if ($util.Long) {
                    var long = new $util.Long(0, 0, true);
                    object.uid = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                } else
                    object.uid = options.longs === String ? "0" : 0;
            if (message.uid != null && message.hasOwnProperty("uid"))
                if (typeof message.uid === "number")
                    object.uid = options.longs === String ? String(message.uid) : message.uid;
                else
                    object.uid = options.longs === String ? $util.Long.prototype.toString.call(message.uid) : options.longs === Number ? new $util.LongBits(message.uid.low >>> 0, message.uid.high >>> 0).toNumber(true) : message.uid;
            return object;
        };

        /**
         * Converts this addTempFriendReq to JSON.
         * @function toJSON
         * @memberof protoCmd.addTempFriendReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        addTempFriendReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return addTempFriendReq;
    })();

    protoCmd.addTempFriendRes = (function() {

        /**
         * Properties of an addTempFriendRes.
         * @memberof protoCmd
         * @interface IaddTempFriendRes
         * @property {boolean|null} [status] addTempFriendRes status
         * @property {string|null} [errorMessage] addTempFriendRes errorMessage
         */

        /**
         * Constructs a new addTempFriendRes.
         * @memberof protoCmd
         * @classdesc Represents an addTempFriendRes.
         * @implements IaddTempFriendRes
         * @constructor
         * @param {protoCmd.IaddTempFriendRes=} [properties] Properties to set
         */
        function addTempFriendRes(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * addTempFriendRes status.
         * @member {boolean} status
         * @memberof protoCmd.addTempFriendRes
         * @instance
         */
        addTempFriendRes.prototype.status = false;

        /**
         * addTempFriendRes errorMessage.
         * @member {string} errorMessage
         * @memberof protoCmd.addTempFriendRes
         * @instance
         */
        addTempFriendRes.prototype.errorMessage = "";

        /**
         * Creates a new addTempFriendRes instance using the specified properties.
         * @function create
         * @memberof protoCmd.addTempFriendRes
         * @static
         * @param {protoCmd.IaddTempFriendRes=} [properties] Properties to set
         * @returns {protoCmd.addTempFriendRes} addTempFriendRes instance
         */
        addTempFriendRes.create = function create(properties) {
            return new addTempFriendRes(properties);
        };

        /**
         * Encodes the specified addTempFriendRes message. Does not implicitly {@link protoCmd.addTempFriendRes.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.addTempFriendRes
         * @static
         * @param {protoCmd.IaddTempFriendRes} message addTempFriendRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        addTempFriendRes.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.status != null && Object.hasOwnProperty.call(message, "status"))
                writer.uint32(/* id 1, wireType 0 =*/8).bool(message.status);
            if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage"))
                writer.uint32(/* id 2, wireType 2 =*/18).string(message.errorMessage);
            return writer;
        };

        /**
         * Encodes the specified addTempFriendRes message, length delimited. Does not implicitly {@link protoCmd.addTempFriendRes.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.addTempFriendRes
         * @static
         * @param {protoCmd.IaddTempFriendRes} message addTempFriendRes message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        addTempFriendRes.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an addTempFriendRes message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.addTempFriendRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.addTempFriendRes} addTempFriendRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        addTempFriendRes.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.addTempFriendRes();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.status = reader.bool();
                    break;
                case 2:
                    message.errorMessage = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes an addTempFriendRes message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.addTempFriendRes
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.addTempFriendRes} addTempFriendRes
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        addTempFriendRes.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an addTempFriendRes message.
         * @function verify
         * @memberof protoCmd.addTempFriendRes
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        addTempFriendRes.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.status != null && message.hasOwnProperty("status"))
                if (typeof message.status !== "boolean")
                    return "status: boolean expected";
            if (message.errorMessage != null && message.hasOwnProperty("errorMessage"))
                if (!$util.isString(message.errorMessage))
                    return "errorMessage: string expected";
            return null;
        };

        /**
         * Creates an addTempFriendRes message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.addTempFriendRes
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.addTempFriendRes} addTempFriendRes
         */
        addTempFriendRes.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.addTempFriendRes)
                return object;
            var message = new $root.protoCmd.addTempFriendRes();
            if (object.status != null)
                message.status = Boolean(object.status);
            if (object.errorMessage != null)
                message.errorMessage = String(object.errorMessage);
            return message;
        };

        /**
         * Creates a plain object from an addTempFriendRes message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.addTempFriendRes
         * @static
         * @param {protoCmd.addTempFriendRes} message addTempFriendRes
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        addTempFriendRes.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                object.status = false;
                object.errorMessage = "";
            }
            if (message.status != null && message.hasOwnProperty("status"))
                object.status = message.status;
            if (message.errorMessage != null && message.hasOwnProperty("errorMessage"))
                object.errorMessage = message.errorMessage;
            return object;
        };

        /**
         * Converts this addTempFriendRes to JSON.
         * @function toJSON
         * @memberof protoCmd.addTempFriendRes
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        addTempFriendRes.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return addTempFriendRes;
    })();

    protoCmd.searchFriendReq = (function() {

        /**
         * Properties of a searchFriendReq.
         * @memberof protoCmd
         * @interface IsearchFriendReq
         * @property {string|null} [name] searchFriendReq name
         */

        /**
         * Constructs a new searchFriendReq.
         * @memberof protoCmd
         * @classdesc Represents a searchFriendReq.
         * @implements IsearchFriendReq
         * @constructor
         * @param {protoCmd.IsearchFriendReq=} [properties] Properties to set
         */
        function searchFriendReq(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * searchFriendReq name.
         * @member {string} name
         * @memberof protoCmd.searchFriendReq
         * @instance
         */
        searchFriendReq.prototype.name = "";

        /**
         * Creates a new searchFriendReq instance using the specified properties.
         * @function create
         * @memberof protoCmd.searchFriendReq
         * @static
         * @param {protoCmd.IsearchFriendReq=} [properties] Properties to set
         * @returns {protoCmd.searchFriendReq} searchFriendReq instance
         */
        searchFriendReq.create = function create(properties) {
            return new searchFriendReq(properties);
        };

        /**
         * Encodes the specified searchFriendReq message. Does not implicitly {@link protoCmd.searchFriendReq.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.searchFriendReq
         * @static
         * @param {protoCmd.IsearchFriendReq} message searchFriendReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        searchFriendReq.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.name != null && Object.hasOwnProperty.call(message, "name"))
                writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
            return writer;
        };

        /**
         * Encodes the specified searchFriendReq message, length delimited. Does not implicitly {@link protoCmd.searchFriendReq.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.searchFriendReq
         * @static
         * @param {protoCmd.IsearchFriendReq} message searchFriendReq message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        searchFriendReq.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a searchFriendReq message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.searchFriendReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.searchFriendReq} searchFriendReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        searchFriendReq.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.searchFriendReq();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.name = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a searchFriendReq message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.searchFriendReq
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.searchFriendReq} searchFriendReq
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        searchFriendReq.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a searchFriendReq message.
         * @function verify
         * @memberof protoCmd.searchFriendReq
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        searchFriendReq.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.name != null && message.hasOwnProperty("name"))
                if (!$util.isString(message.name))
                    return "name: string expected";
            return null;
        };

        /**
         * Creates a searchFriendReq message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.searchFriendReq
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.searchFriendReq} searchFriendReq
         */
        searchFriendReq.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.searchFriendReq)
                return object;
            var message = new $root.protoCmd.searchFriendReq();
            if (object.name != null)
                message.name = String(object.name);
            return message;
        };

        /**
         * Creates a plain object from a searchFriendReq message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.searchFriendReq
         * @static
         * @param {protoCmd.searchFriendReq} message searchFriendReq
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        searchFriendReq.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults)
                object.name = "";
            if (message.name != null && message.hasOwnProperty("name"))
                object.name = message.name;
            return object;
        };

        /**
         * Converts this searchFriendReq to JSON.
         * @function toJSON
         * @memberof protoCmd.searchFriendReq
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        searchFriendReq.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return searchFriendReq;
    })();

    protoCmd.Response = (function() {

        /**
         * Properties of a Response.
         * @memberof protoCmd
         * @interface IResponse
         * @property {string|null} [errorMessage] Response errorMessage
         * @property {protoCmd.IloginRes|null} [loginRes] Response loginRes
         * @property {protoCmd.IgetAllPetRes|null} [getAllPetRes] Response getAllPetRes
         * @property {protoCmd.IgetPetRes|null} [getPetRes] Response getPetRes
         * @property {protoCmd.IuserInfoSyn|null} [userInfoSyn] Response userInfoSyn
         * @property {protoCmd.IshopSyn|null} [shopSyn] Response shopSyn
         * @property {protoCmd.IcommodityRes|null} [commodityRes] Response commodityRes
         * @property {protoCmd.IchangeHeadRes|null} [changeHeadRes] Response changeHeadRes
         * @property {protoCmd.IabandonPetRes|null} [abandonPetRes] Response abandonPetRes
         * @property {protoCmd.IchangeUserNameRes|null} [changeUserNameRes] Response changeUserNameRes
         * @property {protoCmd.IpetNameChangeRes|null} [petNameChangeRes] Response petNameChangeRes
         * @property {protoCmd.ImaintenanceRes|null} [maintenanceRes] Response maintenanceRes
         * @property {protoCmd.IwanderPetSyn|null} [wanderPetSyn] Response wanderPetSyn
         * @property {protoCmd.IwanderPetAdoptReq|null} [wanderPetAdoptReq] Response wanderPetAdoptReq
         * @property {protoCmd.IglobalHeartPing|null} [globalHeartPing] Response globalHeartPing
         * @property {protoCmd.ItaskSyn|null} [taskSyn] Response taskSyn
         * @property {protoCmd.Itaskres|null} [taskres] Response taskres
         * @property {protoCmd.ItaskBoxSyn|null} [taskBoxSyn] Response taskBoxSyn
         * @property {protoCmd.IgetReardHitRes|null} [getReardHitRes] Response getReardHitRes
         * @property {protoCmd.IpetExpRes|null} [petExpRes] Response petExpRes
         * @property {protoCmd.IcdkUseRes|null} [cdkUseRes] Response cdkUseRes
         * @property {protoCmd.ImailSyn|null} [mailSyn] Response mailSyn
         * @property {protoCmd.ImailSingleRes|null} [mailSingleRes] Response mailSingleRes
         * @property {protoCmd.ImailRewardRes|null} [mailRewardRes] Response mailRewardRes
         * @property {protoCmd.IfriendSyn|null} [friendSyn] Response friendSyn
         * @property {protoCmd.IfriendRes|null} [friendRes] Response friendRes
         * @property {protoCmd.IfriendAddRes|null} [friendAddRes] Response friendAddRes
         * @property {protoCmd.ItempFriendRes|null} [tempFriendRes] Response tempFriendRes
         * @property {protoCmd.IaddTempFriendRes|null} [addTempFriendRes] Response addTempFriendRes
         */

        /**
         * Constructs a new Response.
         * @memberof protoCmd
         * @classdesc Represents a Response.
         * @implements IResponse
         * @constructor
         * @param {protoCmd.IResponse=} [properties] Properties to set
         */
        function Response(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * Response errorMessage.
         * @member {string} errorMessage
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.errorMessage = "";

        /**
         * Response loginRes.
         * @member {protoCmd.IloginRes|null|undefined} loginRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.loginRes = null;

        /**
         * Response getAllPetRes.
         * @member {protoCmd.IgetAllPetRes|null|undefined} getAllPetRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.getAllPetRes = null;

        /**
         * Response getPetRes.
         * @member {protoCmd.IgetPetRes|null|undefined} getPetRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.getPetRes = null;

        /**
         * Response userInfoSyn.
         * @member {protoCmd.IuserInfoSyn|null|undefined} userInfoSyn
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.userInfoSyn = null;

        /**
         * Response shopSyn.
         * @member {protoCmd.IshopSyn|null|undefined} shopSyn
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.shopSyn = null;

        /**
         * Response commodityRes.
         * @member {protoCmd.IcommodityRes|null|undefined} commodityRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.commodityRes = null;

        /**
         * Response changeHeadRes.
         * @member {protoCmd.IchangeHeadRes|null|undefined} changeHeadRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.changeHeadRes = null;

        /**
         * Response abandonPetRes.
         * @member {protoCmd.IabandonPetRes|null|undefined} abandonPetRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.abandonPetRes = null;

        /**
         * Response changeUserNameRes.
         * @member {protoCmd.IchangeUserNameRes|null|undefined} changeUserNameRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.changeUserNameRes = null;

        /**
         * Response petNameChangeRes.
         * @member {protoCmd.IpetNameChangeRes|null|undefined} petNameChangeRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.petNameChangeRes = null;

        /**
         * Response maintenanceRes.
         * @member {protoCmd.ImaintenanceRes|null|undefined} maintenanceRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.maintenanceRes = null;

        /**
         * Response wanderPetSyn.
         * @member {protoCmd.IwanderPetSyn|null|undefined} wanderPetSyn
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.wanderPetSyn = null;

        /**
         * Response wanderPetAdoptReq.
         * @member {protoCmd.IwanderPetAdoptReq|null|undefined} wanderPetAdoptReq
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.wanderPetAdoptReq = null;

        /**
         * Response globalHeartPing.
         * @member {protoCmd.IglobalHeartPing|null|undefined} globalHeartPing
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.globalHeartPing = null;

        /**
         * Response taskSyn.
         * @member {protoCmd.ItaskSyn|null|undefined} taskSyn
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.taskSyn = null;

        /**
         * Response taskres.
         * @member {protoCmd.Itaskres|null|undefined} taskres
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.taskres = null;

        /**
         * Response taskBoxSyn.
         * @member {protoCmd.ItaskBoxSyn|null|undefined} taskBoxSyn
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.taskBoxSyn = null;

        /**
         * Response getReardHitRes.
         * @member {protoCmd.IgetReardHitRes|null|undefined} getReardHitRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.getReardHitRes = null;

        /**
         * Response petExpRes.
         * @member {protoCmd.IpetExpRes|null|undefined} petExpRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.petExpRes = null;

        /**
         * Response cdkUseRes.
         * @member {protoCmd.IcdkUseRes|null|undefined} cdkUseRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.cdkUseRes = null;

        /**
         * Response mailSyn.
         * @member {protoCmd.ImailSyn|null|undefined} mailSyn
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.mailSyn = null;

        /**
         * Response mailSingleRes.
         * @member {protoCmd.ImailSingleRes|null|undefined} mailSingleRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.mailSingleRes = null;

        /**
         * Response mailRewardRes.
         * @member {protoCmd.ImailRewardRes|null|undefined} mailRewardRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.mailRewardRes = null;

        /**
         * Response friendSyn.
         * @member {protoCmd.IfriendSyn|null|undefined} friendSyn
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.friendSyn = null;

        /**
         * Response friendRes.
         * @member {protoCmd.IfriendRes|null|undefined} friendRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.friendRes = null;

        /**
         * Response friendAddRes.
         * @member {protoCmd.IfriendAddRes|null|undefined} friendAddRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.friendAddRes = null;

        /**
         * Response tempFriendRes.
         * @member {protoCmd.ItempFriendRes|null|undefined} tempFriendRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.tempFriendRes = null;

        /**
         * Response addTempFriendRes.
         * @member {protoCmd.IaddTempFriendRes|null|undefined} addTempFriendRes
         * @memberof protoCmd.Response
         * @instance
         */
        Response.prototype.addTempFriendRes = null;

        /**
         * Creates a new Response instance using the specified properties.
         * @function create
         * @memberof protoCmd.Response
         * @static
         * @param {protoCmd.IResponse=} [properties] Properties to set
         * @returns {protoCmd.Response} Response instance
         */
        Response.create = function create(properties) {
            return new Response(properties);
        };

        /**
         * Encodes the specified Response message. Does not implicitly {@link protoCmd.Response.verify|verify} messages.
         * @function encode
         * @memberof protoCmd.Response
         * @static
         * @param {protoCmd.IResponse} message Response message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        Response.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage"))
                writer.uint32(/* id 1, wireType 2 =*/10).string(message.errorMessage);
            if (message.loginRes != null && Object.hasOwnProperty.call(message, "loginRes"))
                $root.protoCmd.loginRes.encode(message.loginRes, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
            if (message.getAllPetRes != null && Object.hasOwnProperty.call(message, "getAllPetRes"))
                $root.protoCmd.getAllPetRes.encode(message.getAllPetRes, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
            if (message.getPetRes != null && Object.hasOwnProperty.call(message, "getPetRes"))
                $root.protoCmd.getPetRes.encode(message.getPetRes, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
            if (message.userInfoSyn != null && Object.hasOwnProperty.call(message, "userInfoSyn"))
                $root.protoCmd.userInfoSyn.encode(message.userInfoSyn, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
            if (message.shopSyn != null && Object.hasOwnProperty.call(message, "shopSyn"))
                $root.protoCmd.shopSyn.encode(message.shopSyn, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim();
            if (message.commodityRes != null && Object.hasOwnProperty.call(message, "commodityRes"))
                $root.protoCmd.commodityRes.encode(message.commodityRes, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
            if (message.changeHeadRes != null && Object.hasOwnProperty.call(message, "changeHeadRes"))
                $root.protoCmd.changeHeadRes.encode(message.changeHeadRes, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();
            if (message.abandonPetRes != null && Object.hasOwnProperty.call(message, "abandonPetRes"))
                $root.protoCmd.abandonPetRes.encode(message.abandonPetRes, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();
            if (message.changeUserNameRes != null && Object.hasOwnProperty.call(message, "changeUserNameRes"))
                $root.protoCmd.changeUserNameRes.encode(message.changeUserNameRes, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim();
            if (message.petNameChangeRes != null && Object.hasOwnProperty.call(message, "petNameChangeRes"))
                $root.protoCmd.petNameChangeRes.encode(message.petNameChangeRes, writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim();
            if (message.maintenanceRes != null && Object.hasOwnProperty.call(message, "maintenanceRes"))
                $root.protoCmd.maintenanceRes.encode(message.maintenanceRes, writer.uint32(/* id 12, wireType 2 =*/98).fork()).ldelim();
            if (message.wanderPetSyn != null && Object.hasOwnProperty.call(message, "wanderPetSyn"))
                $root.protoCmd.wanderPetSyn.encode(message.wanderPetSyn, writer.uint32(/* id 13, wireType 2 =*/106).fork()).ldelim();
            if (message.wanderPetAdoptReq != null && Object.hasOwnProperty.call(message, "wanderPetAdoptReq"))
                $root.protoCmd.wanderPetAdoptReq.encode(message.wanderPetAdoptReq, writer.uint32(/* id 14, wireType 2 =*/114).fork()).ldelim();
            if (message.globalHeartPing != null && Object.hasOwnProperty.call(message, "globalHeartPing"))
                $root.protoCmd.globalHeartPing.encode(message.globalHeartPing, writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim();
            if (message.taskSyn != null && Object.hasOwnProperty.call(message, "taskSyn"))
                $root.protoCmd.taskSyn.encode(message.taskSyn, writer.uint32(/* id 16, wireType 2 =*/130).fork()).ldelim();
            if (message.taskres != null && Object.hasOwnProperty.call(message, "taskres"))
                $root.protoCmd.taskres.encode(message.taskres, writer.uint32(/* id 17, wireType 2 =*/138).fork()).ldelim();
            if (message.taskBoxSyn != null && Object.hasOwnProperty.call(message, "taskBoxSyn"))
                $root.protoCmd.taskBoxSyn.encode(message.taskBoxSyn, writer.uint32(/* id 18, wireType 2 =*/146).fork()).ldelim();
            if (message.getReardHitRes != null && Object.hasOwnProperty.call(message, "getReardHitRes"))
                $root.protoCmd.getReardHitRes.encode(message.getReardHitRes, writer.uint32(/* id 19, wireType 2 =*/154).fork()).ldelim();
            if (message.petExpRes != null && Object.hasOwnProperty.call(message, "petExpRes"))
                $root.protoCmd.petExpRes.encode(message.petExpRes, writer.uint32(/* id 20, wireType 2 =*/162).fork()).ldelim();
            if (message.cdkUseRes != null && Object.hasOwnProperty.call(message, "cdkUseRes"))
                $root.protoCmd.cdkUseRes.encode(message.cdkUseRes, writer.uint32(/* id 21, wireType 2 =*/170).fork()).ldelim();
            if (message.mailSyn != null && Object.hasOwnProperty.call(message, "mailSyn"))
                $root.protoCmd.mailSyn.encode(message.mailSyn, writer.uint32(/* id 22, wireType 2 =*/178).fork()).ldelim();
            if (message.mailSingleRes != null && Object.hasOwnProperty.call(message, "mailSingleRes"))
                $root.protoCmd.mailSingleRes.encode(message.mailSingleRes, writer.uint32(/* id 23, wireType 2 =*/186).fork()).ldelim();
            if (message.mailRewardRes != null && Object.hasOwnProperty.call(message, "mailRewardRes"))
                $root.protoCmd.mailRewardRes.encode(message.mailRewardRes, writer.uint32(/* id 24, wireType 2 =*/194).fork()).ldelim();
            if (message.friendSyn != null && Object.hasOwnProperty.call(message, "friendSyn"))
                $root.protoCmd.friendSyn.encode(message.friendSyn, writer.uint32(/* id 25, wireType 2 =*/202).fork()).ldelim();
            if (message.friendRes != null && Object.hasOwnProperty.call(message, "friendRes"))
                $root.protoCmd.friendRes.encode(message.friendRes, writer.uint32(/* id 26, wireType 2 =*/210).fork()).ldelim();
            if (message.friendAddRes != null && Object.hasOwnProperty.call(message, "friendAddRes"))
                $root.protoCmd.friendAddRes.encode(message.friendAddRes, writer.uint32(/* id 27, wireType 2 =*/218).fork()).ldelim();
            if (message.tempFriendRes != null && Object.hasOwnProperty.call(message, "tempFriendRes"))
                $root.protoCmd.tempFriendRes.encode(message.tempFriendRes, writer.uint32(/* id 28, wireType 2 =*/226).fork()).ldelim();
            if (message.addTempFriendRes != null && Object.hasOwnProperty.call(message, "addTempFriendRes"))
                $root.protoCmd.addTempFriendRes.encode(message.addTempFriendRes, writer.uint32(/* id 29, wireType 2 =*/234).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified Response message, length delimited. Does not implicitly {@link protoCmd.Response.verify|verify} messages.
         * @function encodeDelimited
         * @memberof protoCmd.Response
         * @static
         * @param {protoCmd.IResponse} message Response message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        Response.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a Response message from the specified reader or buffer.
         * @function decode
         * @memberof protoCmd.Response
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {protoCmd.Response} Response
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        Response.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.protoCmd.Response();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.errorMessage = reader.string();
                    break;
                case 2:
                    message.loginRes = $root.protoCmd.loginRes.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.getAllPetRes = $root.protoCmd.getAllPetRes.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.getPetRes = $root.protoCmd.getPetRes.decode(reader, reader.uint32());
                    break;
                case 5:
                    message.userInfoSyn = $root.protoCmd.userInfoSyn.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.shopSyn = $root.protoCmd.shopSyn.decode(reader, reader.uint32());
                    break;
                case 7:
                    message.commodityRes = $root.protoCmd.commodityRes.decode(reader, reader.uint32());
                    break;
                case 8:
                    message.changeHeadRes = $root.protoCmd.changeHeadRes.decode(reader, reader.uint32());
                    break;
                case 9:
                    message.abandonPetRes = $root.protoCmd.abandonPetRes.decode(reader, reader.uint32());
                    break;
                case 10:
                    message.changeUserNameRes = $root.protoCmd.changeUserNameRes.decode(reader, reader.uint32());
                    break;
                case 11:
                    message.petNameChangeRes = $root.protoCmd.petNameChangeRes.decode(reader, reader.uint32());
                    break;
                case 12:
                    message.maintenanceRes = $root.protoCmd.maintenanceRes.decode(reader, reader.uint32());
                    break;
                case 13:
                    message.wanderPetSyn = $root.protoCmd.wanderPetSyn.decode(reader, reader.uint32());
                    break;
                case 14:
                    message.wanderPetAdoptReq = $root.protoCmd.wanderPetAdoptReq.decode(reader, reader.uint32());
                    break;
                case 15:
                    message.globalHeartPing = $root.protoCmd.globalHeartPing.decode(reader, reader.uint32());
                    break;
                case 16:
                    message.taskSyn = $root.protoCmd.taskSyn.decode(reader, reader.uint32());
                    break;
                case 17:
                    message.taskres = $root.protoCmd.taskres.decode(reader, reader.uint32());
                    break;
                case 18:
                    message.taskBoxSyn = $root.protoCmd.taskBoxSyn.decode(reader, reader.uint32());
                    break;
                case 19:
                    message.getReardHitRes = $root.protoCmd.getReardHitRes.decode(reader, reader.uint32());
                    break;
                case 20:
                    message.petExpRes = $root.protoCmd.petExpRes.decode(reader, reader.uint32());
                    break;
                case 21:
                    message.cdkUseRes = $root.protoCmd.cdkUseRes.decode(reader, reader.uint32());
                    break;
                case 22:
                    message.mailSyn = $root.protoCmd.mailSyn.decode(reader, reader.uint32());
                    break;
                case 23:
                    message.mailSingleRes = $root.protoCmd.mailSingleRes.decode(reader, reader.uint32());
                    break;
                case 24:
                    message.mailRewardRes = $root.protoCmd.mailRewardRes.decode(reader, reader.uint32());
                    break;
                case 25:
                    message.friendSyn = $root.protoCmd.friendSyn.decode(reader, reader.uint32());
                    break;
                case 26:
                    message.friendRes = $root.protoCmd.friendRes.decode(reader, reader.uint32());
                    break;
                case 27:
                    message.friendAddRes = $root.protoCmd.friendAddRes.decode(reader, reader.uint32());
                    break;
                case 28:
                    message.tempFriendRes = $root.protoCmd.tempFriendRes.decode(reader, reader.uint32());
                    break;
                case 29:
                    message.addTempFriendRes = $root.protoCmd.addTempFriendRes.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a Response message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof protoCmd.Response
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {protoCmd.Response} Response
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        Response.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a Response message.
         * @function verify
         * @memberof protoCmd.Response
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        Response.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.errorMessage != null && message.hasOwnProperty("errorMessage"))
                if (!$util.isString(message.errorMessage))
                    return "errorMessage: string expected";
            if (message.loginRes != null && message.hasOwnProperty("loginRes")) {
                var error = $root.protoCmd.loginRes.verify(message.loginRes);
                if (error)
                    return "loginRes." + error;
            }
            if (message.getAllPetRes != null && message.hasOwnProperty("getAllPetRes")) {
                var error = $root.protoCmd.getAllPetRes.verify(message.getAllPetRes);
                if (error)
                    return "getAllPetRes." + error;
            }
            if (message.getPetRes != null && message.hasOwnProperty("getPetRes")) {
                var error = $root.protoCmd.getPetRes.verify(message.getPetRes);
                if (error)
                    return "getPetRes." + error;
            }
            if (message.userInfoSyn != null && message.hasOwnProperty("userInfoSyn")) {
                var error = $root.protoCmd.userInfoSyn.verify(message.userInfoSyn);
                if (error)
                    return "userInfoSyn." + error;
            }
            if (message.shopSyn != null && message.hasOwnProperty("shopSyn")) {
                var error = $root.protoCmd.shopSyn.verify(message.shopSyn);
                if (error)
                    return "shopSyn." + error;
            }
            if (message.commodityRes != null && message.hasOwnProperty("commodityRes")) {
                var error = $root.protoCmd.commodityRes.verify(message.commodityRes);
                if (error)
                    return "commodityRes." + error;
            }
            if (message.changeHeadRes != null && message.hasOwnProperty("changeHeadRes")) {
                var error = $root.protoCmd.changeHeadRes.verify(message.changeHeadRes);
                if (error)
                    return "changeHeadRes." + error;
            }
            if (message.abandonPetRes != null && message.hasOwnProperty("abandonPetRes")) {
                var error = $root.protoCmd.abandonPetRes.verify(message.abandonPetRes);
                if (error)
                    return "abandonPetRes." + error;
            }
            if (message.changeUserNameRes != null && message.hasOwnProperty("changeUserNameRes")) {
                var error = $root.protoCmd.changeUserNameRes.verify(message.changeUserNameRes);
                if (error)
                    return "changeUserNameRes." + error;
            }
            if (message.petNameChangeRes != null && message.hasOwnProperty("petNameChangeRes")) {
                var error = $root.protoCmd.petNameChangeRes.verify(message.petNameChangeRes);
                if (error)
                    return "petNameChangeRes." + error;
            }
            if (message.maintenanceRes != null && message.hasOwnProperty("maintenanceRes")) {
                var error = $root.protoCmd.maintenanceRes.verify(message.maintenanceRes);
                if (error)
                    return "maintenanceRes." + error;
            }
            if (message.wanderPetSyn != null && message.hasOwnProperty("wanderPetSyn")) {
                var error = $root.protoCmd.wanderPetSyn.verify(message.wanderPetSyn);
                if (error)
                    return "wanderPetSyn." + error;
            }
            if (message.wanderPetAdoptReq != null && message.hasOwnProperty("wanderPetAdoptReq")) {
                var error = $root.protoCmd.wanderPetAdoptReq.verify(message.wanderPetAdoptReq);
                if (error)
                    return "wanderPetAdoptReq." + error;
            }
            if (message.globalHeartPing != null && message.hasOwnProperty("globalHeartPing")) {
                var error = $root.protoCmd.globalHeartPing.verify(message.globalHeartPing);
                if (error)
                    return "globalHeartPing." + error;
            }
            if (message.taskSyn != null && message.hasOwnProperty("taskSyn")) {
                var error = $root.protoCmd.taskSyn.verify(message.taskSyn);
                if (error)
                    return "taskSyn." + error;
            }
            if (message.taskres != null && message.hasOwnProperty("taskres")) {
                var error = $root.protoCmd.taskres.verify(message.taskres);
                if (error)
                    return "taskres." + error;
            }
            if (message.taskBoxSyn != null && message.hasOwnProperty("taskBoxSyn")) {
                var error = $root.protoCmd.taskBoxSyn.verify(message.taskBoxSyn);
                if (error)
                    return "taskBoxSyn." + error;
            }
            if (message.getReardHitRes != null && message.hasOwnProperty("getReardHitRes")) {
                var error = $root.protoCmd.getReardHitRes.verify(message.getReardHitRes);
                if (error)
                    return "getReardHitRes." + error;
            }
            if (message.petExpRes != null && message.hasOwnProperty("petExpRes")) {
                var error = $root.protoCmd.petExpRes.verify(message.petExpRes);
                if (error)
                    return "petExpRes." + error;
            }
            if (message.cdkUseRes != null && message.hasOwnProperty("cdkUseRes")) {
                var error = $root.protoCmd.cdkUseRes.verify(message.cdkUseRes);
                if (error)
                    return "cdkUseRes." + error;
            }
            if (message.mailSyn != null && message.hasOwnProperty("mailSyn")) {
                var error = $root.protoCmd.mailSyn.verify(message.mailSyn);
                if (error)
                    return "mailSyn." + error;
            }
            if (message.mailSingleRes != null && message.hasOwnProperty("mailSingleRes")) {
                var error = $root.protoCmd.mailSingleRes.verify(message.mailSingleRes);
                if (error)
                    return "mailSingleRes." + error;
            }
            if (message.mailRewardRes != null && message.hasOwnProperty("mailRewardRes")) {
                var error = $root.protoCmd.mailRewardRes.verify(message.mailRewardRes);
                if (error)
                    return "mailRewardRes." + error;
            }
            if (message.friendSyn != null && message.hasOwnProperty("friendSyn")) {
                var error = $root.protoCmd.friendSyn.verify(message.friendSyn);
                if (error)
                    return "friendSyn." + error;
            }
            if (message.friendRes != null && message.hasOwnProperty("friendRes")) {
                var error = $root.protoCmd.friendRes.verify(message.friendRes);
                if (error)
                    return "friendRes." + error;
            }
            if (message.friendAddRes != null && message.hasOwnProperty("friendAddRes")) {
                var error = $root.protoCmd.friendAddRes.verify(message.friendAddRes);
                if (error)
                    return "friendAddRes." + error;
            }
            if (message.tempFriendRes != null && message.hasOwnProperty("tempFriendRes")) {
                var error = $root.protoCmd.tempFriendRes.verify(message.tempFriendRes);
                if (error)
                    return "tempFriendRes." + error;
            }
            if (message.addTempFriendRes != null && message.hasOwnProperty("addTempFriendRes")) {
                var error = $root.protoCmd.addTempFriendRes.verify(message.addTempFriendRes);
                if (error)
                    return "addTempFriendRes." + error;
            }
            return null;
        };

        /**
         * Creates a Response message from a plain object. Also converts values to their respective internal types.
         * @function fromObject
         * @memberof protoCmd.Response
         * @static
         * @param {Object.<string,*>} object Plain object
         * @returns {protoCmd.Response} Response
         */
        Response.fromObject = function fromObject(object) {
            if (object instanceof $root.protoCmd.Response)
                return object;
            var message = new $root.protoCmd.Response();
            if (object.errorMessage != null)
                message.errorMessage = String(object.errorMessage);
            if (object.loginRes != null) {
                if (typeof object.loginRes !== "object")
                    throw TypeError(".protoCmd.Response.loginRes: object expected");
                message.loginRes = $root.protoCmd.loginRes.fromObject(object.loginRes);
            }
            if (object.getAllPetRes != null) {
                if (typeof object.getAllPetRes !== "object")
                    throw TypeError(".protoCmd.Response.getAllPetRes: object expected");
                message.getAllPetRes = $root.protoCmd.getAllPetRes.fromObject(object.getAllPetRes);
            }
            if (object.getPetRes != null) {
                if (typeof object.getPetRes !== "object")
                    throw TypeError(".protoCmd.Response.getPetRes: object expected");
                message.getPetRes = $root.protoCmd.getPetRes.fromObject(object.getPetRes);
            }
            if (object.userInfoSyn != null) {
                if (typeof object.userInfoSyn !== "object")
                    throw TypeError(".protoCmd.Response.userInfoSyn: object expected");
                message.userInfoSyn = $root.protoCmd.userInfoSyn.fromObject(object.userInfoSyn);
            }
            if (object.shopSyn != null) {
                if (typeof object.shopSyn !== "object")
                    throw TypeError(".protoCmd.Response.shopSyn: object expected");
                message.shopSyn = $root.protoCmd.shopSyn.fromObject(object.shopSyn);
            }
            if (object.commodityRes != null) {
                if (typeof object.commodityRes !== "object")
                    throw TypeError(".protoCmd.Response.commodityRes: object expected");
                message.commodityRes = $root.protoCmd.commodityRes.fromObject(object.commodityRes);
            }
            if (object.changeHeadRes != null) {
                if (typeof object.changeHeadRes !== "object")
                    throw TypeError(".protoCmd.Response.changeHeadRes: object expected");
                message.changeHeadRes = $root.protoCmd.changeHeadRes.fromObject(object.changeHeadRes);
            }
            if (object.abandonPetRes != null) {
                if (typeof object.abandonPetRes !== "object")
                    throw TypeError(".protoCmd.Response.abandonPetRes: object expected");
                message.abandonPetRes = $root.protoCmd.abandonPetRes.fromObject(object.abandonPetRes);
            }
            if (object.changeUserNameRes != null) {
                if (typeof object.changeUserNameRes !== "object")
                    throw TypeError(".protoCmd.Response.changeUserNameRes: object expected");
                message.changeUserNameRes = $root.protoCmd.changeUserNameRes.fromObject(object.changeUserNameRes);
            }
            if (object.petNameChangeRes != null) {
                if (typeof object.petNameChangeRes !== "object")
                    throw TypeError(".protoCmd.Response.petNameChangeRes: object expected");
                message.petNameChangeRes = $root.protoCmd.petNameChangeRes.fromObject(object.petNameChangeRes);
            }
            if (object.maintenanceRes != null) {
                if (typeof object.maintenanceRes !== "object")
                    throw TypeError(".protoCmd.Response.maintenanceRes: object expected");
                message.maintenanceRes = $root.protoCmd.maintenanceRes.fromObject(object.maintenanceRes);
            }
            if (object.wanderPetSyn != null) {
                if (typeof object.wanderPetSyn !== "object")
                    throw TypeError(".protoCmd.Response.wanderPetSyn: object expected");
                message.wanderPetSyn = $root.protoCmd.wanderPetSyn.fromObject(object.wanderPetSyn);
            }
            if (object.wanderPetAdoptReq != null) {
                if (typeof object.wanderPetAdoptReq !== "object")
                    throw TypeError(".protoCmd.Response.wanderPetAdoptReq: object expected");
                message.wanderPetAdoptReq = $root.protoCmd.wanderPetAdoptReq.fromObject(object.wanderPetAdoptReq);
            }
            if (object.globalHeartPing != null) {
                if (typeof object.globalHeartPing !== "object")
                    throw TypeError(".protoCmd.Response.globalHeartPing: object expected");
                message.globalHeartPing = $root.protoCmd.globalHeartPing.fromObject(object.globalHeartPing);
            }
            if (object.taskSyn != null) {
                if (typeof object.taskSyn !== "object")
                    throw TypeError(".protoCmd.Response.taskSyn: object expected");
                message.taskSyn = $root.protoCmd.taskSyn.fromObject(object.taskSyn);
            }
            if (object.taskres != null) {
                if (typeof object.taskres !== "object")
                    throw TypeError(".protoCmd.Response.taskres: object expected");
                message.taskres = $root.protoCmd.taskres.fromObject(object.taskres);
            }
            if (object.taskBoxSyn != null) {
                if (typeof object.taskBoxSyn !== "object")
                    throw TypeError(".protoCmd.Response.taskBoxSyn: object expected");
                message.taskBoxSyn = $root.protoCmd.taskBoxSyn.fromObject(object.taskBoxSyn);
            }
            if (object.getReardHitRes != null) {
                if (typeof object.getReardHitRes !== "object")
                    throw TypeError(".protoCmd.Response.getReardHitRes: object expected");
                message.getReardHitRes = $root.protoCmd.getReardHitRes.fromObject(object.getReardHitRes);
            }
            if (object.petExpRes != null) {
                if (typeof object.petExpRes !== "object")
                    throw TypeError(".protoCmd.Response.petExpRes: object expected");
                message.petExpRes = $root.protoCmd.petExpRes.fromObject(object.petExpRes);
            }
            if (object.cdkUseRes != null) {
                if (typeof object.cdkUseRes !== "object")
                    throw TypeError(".protoCmd.Response.cdkUseRes: object expected");
                message.cdkUseRes = $root.protoCmd.cdkUseRes.fromObject(object.cdkUseRes);
            }
            if (object.mailSyn != null) {
                if (typeof object.mailSyn !== "object")
                    throw TypeError(".protoCmd.Response.mailSyn: object expected");
                message.mailSyn = $root.protoCmd.mailSyn.fromObject(object.mailSyn);
            }
            if (object.mailSingleRes != null) {
                if (typeof object.mailSingleRes !== "object")
                    throw TypeError(".protoCmd.Response.mailSingleRes: object expected");
                message.mailSingleRes = $root.protoCmd.mailSingleRes.fromObject(object.mailSingleRes);
            }
            if (object.mailRewardRes != null) {
                if (typeof object.mailRewardRes !== "object")
                    throw TypeError(".protoCmd.Response.mailRewardRes: object expected");
                message.mailRewardRes = $root.protoCmd.mailRewardRes.fromObject(object.mailRewardRes);
            }
            if (object.friendSyn != null) {
                if (typeof object.friendSyn !== "object")
                    throw TypeError(".protoCmd.Response.friendSyn: object expected");
                message.friendSyn = $root.protoCmd.friendSyn.fromObject(object.friendSyn);
            }
            if (object.friendRes != null) {
                if (typeof object.friendRes !== "object")
                    throw TypeError(".protoCmd.Response.friendRes: object expected");
                message.friendRes = $root.protoCmd.friendRes.fromObject(object.friendRes);
            }
            if (object.friendAddRes != null) {
                if (typeof object.friendAddRes !== "object")
                    throw TypeError(".protoCmd.Response.friendAddRes: object expected");
                message.friendAddRes = $root.protoCmd.friendAddRes.fromObject(object.friendAddRes);
            }
            if (object.tempFriendRes != null) {
                if (typeof object.tempFriendRes !== "object")
                    throw TypeError(".protoCmd.Response.tempFriendRes: object expected");
                message.tempFriendRes = $root.protoCmd.tempFriendRes.fromObject(object.tempFriendRes);
            }
            if (object.addTempFriendRes != null) {
                if (typeof object.addTempFriendRes !== "object")
                    throw TypeError(".protoCmd.Response.addTempFriendRes: object expected");
                message.addTempFriendRes = $root.protoCmd.addTempFriendRes.fromObject(object.addTempFriendRes);
            }
            return message;
        };

        /**
         * Creates a plain object from a Response message. Also converts values to other types if specified.
         * @function toObject
         * @memberof protoCmd.Response
         * @static
         * @param {protoCmd.Response} message Response
         * @param {$protobuf.IConversionOptions} [options] Conversion options
         * @returns {Object.<string,*>} Plain object
         */
        Response.toObject = function toObject(message, options) {
            if (!options)
                options = {};
            var object = {};
            if (options.defaults) {
                object.errorMessage = "";
                object.loginRes = null;
                object.getAllPetRes = null;
                object.getPetRes = null;
                object.userInfoSyn = null;
                object.shopSyn = null;
                object.commodityRes = null;
                object.changeHeadRes = null;
                object.abandonPetRes = null;
                object.changeUserNameRes = null;
                object.petNameChangeRes = null;
                object.maintenanceRes = null;
                object.wanderPetSyn = null;
                object.wanderPetAdoptReq = null;
                object.globalHeartPing = null;
                object.taskSyn = null;
                object.taskres = null;
                object.taskBoxSyn = null;
                object.getReardHitRes = null;
                object.petExpRes = null;
                object.cdkUseRes = null;
                object.mailSyn = null;
                object.mailSingleRes = null;
                object.mailRewardRes = null;
                object.friendSyn = null;
                object.friendRes = null;
                object.friendAddRes = null;
                object.tempFriendRes = null;
                object.addTempFriendRes = null;
            }
            if (message.errorMessage != null && message.hasOwnProperty("errorMessage"))
                object.errorMessage = message.errorMessage;
            if (message.loginRes != null && message.hasOwnProperty("loginRes"))
                object.loginRes = $root.protoCmd.loginRes.toObject(message.loginRes, options);
            if (message.getAllPetRes != null && message.hasOwnProperty("getAllPetRes"))
                object.getAllPetRes = $root.protoCmd.getAllPetRes.toObject(message.getAllPetRes, options);
            if (message.getPetRes != null && message.hasOwnProperty("getPetRes"))
                object.getPetRes = $root.protoCmd.getPetRes.toObject(message.getPetRes, options);
            if (message.userInfoSyn != null && message.hasOwnProperty("userInfoSyn"))
                object.userInfoSyn = $root.protoCmd.userInfoSyn.toObject(message.userInfoSyn, options);
            if (message.shopSyn != null && message.hasOwnProperty("shopSyn"))
                object.shopSyn = $root.protoCmd.shopSyn.toObject(message.shopSyn, options);
            if (message.commodityRes != null && message.hasOwnProperty("commodityRes"))
                object.commodityRes = $root.protoCmd.commodityRes.toObject(message.commodityRes, options);
            if (message.changeHeadRes != null && message.hasOwnProperty("changeHeadRes"))
                object.changeHeadRes = $root.protoCmd.changeHeadRes.toObject(message.changeHeadRes, options);
            if (message.abandonPetRes != null && message.hasOwnProperty("abandonPetRes"))
                object.abandonPetRes = $root.protoCmd.abandonPetRes.toObject(message.abandonPetRes, options);
            if (message.changeUserNameRes != null && message.hasOwnProperty("changeUserNameRes"))
                object.changeUserNameRes = $root.protoCmd.changeUserNameRes.toObject(message.changeUserNameRes, options);
            if (message.petNameChangeRes != null && message.hasOwnProperty("petNameChangeRes"))
                object.petNameChangeRes = $root.protoCmd.petNameChangeRes.toObject(message.petNameChangeRes, options);
            if (message.maintenanceRes != null && message.hasOwnProperty("maintenanceRes"))
                object.maintenanceRes = $root.protoCmd.maintenanceRes.toObject(message.maintenanceRes, options);
            if (message.wanderPetSyn != null && message.hasOwnProperty("wanderPetSyn"))
                object.wanderPetSyn = $root.protoCmd.wanderPetSyn.toObject(message.wanderPetSyn, options);
            if (message.wanderPetAdoptReq != null && message.hasOwnProperty("wanderPetAdoptReq"))
                object.wanderPetAdoptReq = $root.protoCmd.wanderPetAdoptReq.toObject(message.wanderPetAdoptReq, options);
            if (message.globalHeartPing != null && message.hasOwnProperty("globalHeartPing"))
                object.globalHeartPing = $root.protoCmd.globalHeartPing.toObject(message.globalHeartPing, options);
            if (message.taskSyn != null && message.hasOwnProperty("taskSyn"))
                object.taskSyn = $root.protoCmd.taskSyn.toObject(message.taskSyn, options);
            if (message.taskres != null && message.hasOwnProperty("taskres"))
                object.taskres = $root.protoCmd.taskres.toObject(message.taskres, options);
            if (message.taskBoxSyn != null && message.hasOwnProperty("taskBoxSyn"))
                object.taskBoxSyn = $root.protoCmd.taskBoxSyn.toObject(message.taskBoxSyn, options);
            if (message.getReardHitRes != null && message.hasOwnProperty("getReardHitRes"))
                object.getReardHitRes = $root.protoCmd.getReardHitRes.toObject(message.getReardHitRes, options);
            if (message.petExpRes != null && message.hasOwnProperty("petExpRes"))
                object.petExpRes = $root.protoCmd.petExpRes.toObject(message.petExpRes, options);
            if (message.cdkUseRes != null && message.hasOwnProperty("cdkUseRes"))
                object.cdkUseRes = $root.protoCmd.cdkUseRes.toObject(message.cdkUseRes, options);
            if (message.mailSyn != null && message.hasOwnProperty("mailSyn"))
                object.mailSyn = $root.protoCmd.mailSyn.toObject(message.mailSyn, options);
            if (message.mailSingleRes != null && message.hasOwnProperty("mailSingleRes"))
                object.mailSingleRes = $root.protoCmd.mailSingleRes.toObject(message.mailSingleRes, options);
            if (message.mailRewardRes != null && message.hasOwnProperty("mailRewardRes"))
                object.mailRewardRes = $root.protoCmd.mailRewardRes.toObject(message.mailRewardRes, options);
            if (message.friendSyn != null && message.hasOwnProperty("friendSyn"))
                object.friendSyn = $root.protoCmd.friendSyn.toObject(message.friendSyn, options);
            if (message.friendRes != null && message.hasOwnProperty("friendRes"))
                object.friendRes = $root.protoCmd.friendRes.toObject(message.friendRes, options);
            if (message.friendAddRes != null && message.hasOwnProperty("friendAddRes"))
                object.friendAddRes = $root.protoCmd.friendAddRes.toObject(message.friendAddRes, options);
            if (message.tempFriendRes != null && message.hasOwnProperty("tempFriendRes"))
                object.tempFriendRes = $root.protoCmd.tempFriendRes.toObject(message.tempFriendRes, options);
            if (message.addTempFriendRes != null && message.hasOwnProperty("addTempFriendRes"))
                object.addTempFriendRes = $root.protoCmd.addTempFriendRes.toObject(message.addTempFriendRes, options);
            return object;
        };

        /**
         * Converts this Response to JSON.
         * @function toJSON
         * @memberof protoCmd.Response
         * @instance
         * @returns {Object.<string,*>} JSON object
         */
        Response.prototype.toJSON = function toJSON() {
            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
        };

        return Response;
    })();

    return protoCmd;
})();

module.exports = $root;
